diff --git a/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs b/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs
new file mode 100644
index 00000000000..89789ef4a5e
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.RenderPipelines.Core.Editor.Tests")]
diff --git a/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs.meta b/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs.meta
new file mode 100644
index 00000000000..0ad9d21fa83
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/AssemblyInfo.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 29e065a6b65d48e69e4dac2a4017d950
+timeCreated: 1639647529
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Editor/Utilities/Attribute.meta b/com.unity.render-pipelines.core/Editor/Utilities/Attribute.meta
new file mode 100644
index 00000000000..e1027c7c902
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/Utilities/Attribute.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d3d03e9a9d41e6f4a92aa0326d7f4a49
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentContext.cs b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentContext.cs
new file mode 100644
index 00000000000..e2af2ae4553
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentContext.cs
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Rendering
+{
+    /// <summary>
+    /// A context for volume components
+    /// </summary>
+    // Do not expose, context is a workaround to a bad UX, VolumeProfile should only accept a specific archetype
+    class VolumeComponentContext
+    {
+        // what archetype to use when displaying an Add Volume Override menu
+        [NotNull]
+        [ExcludeFromCodeCoverage] // trivial
+        public VolumeComponentArchetype contextualArchetype { get; private set; } = VolumeComponentArchetype.Empty;
+
+        HashSet<VolumeComponentArchetype> s_Includes = new HashSet<VolumeComponentArchetype>();
+        HashSet<VolumeComponentArchetype> s_Excludes = new HashSet<VolumeComponentArchetype>();
+
+        [ExcludeFromCodeCoverage] // trivial
+        public VolumeComponentContext()
+        {
+            AddExcludeArchetype(VolumeComponentArchetype.FromFilterCached(IsVisibleVolumeComponentFilter.FromIsVisible(false)));
+        }
+
+        [ExcludeFromCodeCoverage] // trivial wraps of `VolumeComponentArchetype.FromIncludeExclude`
+        public void AddIncludeArchetype([DisallowNull] VolumeComponentArchetype archetype)
+        {
+            s_Includes.Add(archetype);
+            contextualArchetype = VolumeComponentArchetype.FromIncludeExclude(s_Includes, s_Excludes);
+        }
+
+        [ExcludeFromCodeCoverage] // trivial wraps of `VolumeComponentArchetype.FromIncludeExclude`
+        public void RemoveIncludeArchetype([DisallowNull] VolumeComponentArchetype archetype)
+        {
+            s_Includes.Remove(archetype);
+            contextualArchetype = VolumeComponentArchetype.FromIncludeExclude(s_Includes, s_Excludes);
+        }
+
+        [ExcludeFromCodeCoverage] // trivial wraps of `VolumeComponentArchetype.FromIncludeExclude`
+        public void AddExcludeArchetype([DisallowNull] VolumeComponentArchetype archetype)
+        {
+            s_Excludes.Add(archetype);
+            contextualArchetype = VolumeComponentArchetype.FromIncludeExclude(s_Includes, s_Excludes);
+        }
+
+        [ExcludeFromCodeCoverage] // trivial wraps of `VolumeComponentArchetype.FromIncludeExclude`
+        public void RemoveExcludeArchetype([DisallowNull] VolumeComponentArchetype archetype)
+        {
+            s_Excludes.Remove(archetype);
+            contextualArchetype = VolumeComponentArchetype.FromIncludeExclude(s_Includes, s_Excludes);
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentProvider.cs.meta b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentContext.cs.meta
similarity index 83%
rename from com.unity.render-pipelines.core/Editor/Volume/VolumeComponentProvider.cs.meta
rename to com.unity.render-pipelines.core/Editor/Volume/VolumeComponentContext.cs.meta
index a0e3ec6d5a7..b89e45bb8c2 100644
--- a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentProvider.cs.meta
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentContext.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 7d7e09e271ad3fd4c9ceb1873a5fb59e
+guid: a5dd758b7378b9848a4c11bd4b8acd8f
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentEditor.cs b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentEditor.cs
index ec2540dda56..ae9aa656739 100644
--- a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentEditor.cs
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentEditor.cs
@@ -356,8 +356,9 @@ public virtual GUIContent GetDisplayTitle()
         {
             var targetType = target.GetType();
             string title = string.IsNullOrEmpty(volumeComponent.displayName) ? ObjectNames.NicifyVariableName(volumeComponent.GetType().Name) : volumeComponent.displayName;
-            string tooltip = targetType.GetCustomAttribute(typeof(VolumeComponentMenuForRenderPipeline), false) is VolumeComponentMenuForRenderPipeline supportedOn
-                ? string.Join(", ", supportedOn.pipelineTypes.Select(t => ObjectNames.NicifyVariableName(t.Name)))
+            var supportedTypes = targetType.GetCustomAttributes<SupportedOnAttribute>().Select(attr => ObjectNames.NicifyVariableName(attr.target.Name)).ToArray();
+            string tooltip = supportedTypes.Length > 0
+                ? string.Join(", ", supportedTypes)
                 : string.Empty;
             return EditorGUIUtility.TrTextContent(title, tooltip);
         }
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentListEditor.cs b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentListEditor.cs
index f95cb644dd5..b602eeba9bf 100644
--- a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentListEditor.cs
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentListEditor.cs
@@ -245,7 +245,7 @@ public void OnGUI()
                     {
                         var r = hscope.rect;
                         var pos = new Vector2(r.x + r.width / 2f, r.yMax + 18f);
-                        FilterWindow.Show(pos, new VolumeComponentProvider(asset, this));
+                        FilterWindow.Show(pos, new VolumeComponentTreeProvider(asset, this, null));
                     }
                 }
             }
@@ -282,7 +282,7 @@ void OnContextClick(Vector2 position, VolumeComponentEditor targetEditor, int id
             menu.AddItem(EditorGUIUtility.TrTextContent("Collapse All"), false, () => CollapseComponents());
             menu.AddItem(EditorGUIUtility.TrTextContent("Expand All"), false, () => ExpandComponents());
             menu.AddSeparator(string.Empty);
-            menu.AddItem(EditorGUIUtility.TrTextContent("Reset"), false, () => ResetComponent(targetComponent.GetType(), id));
+            menu.AddItem(EditorGUIUtility.TrTextContent("Reset"), false, () => ResetComponent(VolumeComponentType.FromTypeUnsafe(targetComponent.GetType()), id));
             menu.AddItem(EditorGUIUtility.TrTextContent("Remove"), false, () => RemoveComponent(id));
             menu.AddSeparator(string.Empty);
             if (targetEditor.hasAdditionalProperties)
@@ -306,15 +306,15 @@ void OnContextClick(Vector2 position, VolumeComponentEditor targetEditor, int id
             menu.DropDown(new Rect(position, Vector2.zero));
         }
 
-        VolumeComponent CreateNewComponent(Type type)
+        static VolumeComponent CreateNewComponent(VolumeComponentType type)
         {
-            var effect = (VolumeComponent)ScriptableObject.CreateInstance(type);
+            var effect = (VolumeComponent)ScriptableObject.CreateInstance(type.AsType());
             effect.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
-            effect.name = type.Name;
+            effect.name = type.AsType().Name;
             return effect;
         }
 
-        internal void AddComponent(Type type)
+        internal void AddComponent(VolumeComponentType type)
         {
             m_SerializedObject.Update();
 
@@ -388,7 +388,7 @@ internal void RemoveComponent(int id)
 
         // Reset is done by deleting and removing the object from the list and adding a new one in
         // the same spot as it was before
-        internal void ResetComponent(Type type, int id)
+        internal void ResetComponent(VolumeComponentType type, int id)
         {
             // Remove from the cached editors list
             m_Editors[id].OnDisable();
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentProvider.cs b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentProvider.cs
deleted file mode 100644
index e61718d786e..00000000000
--- a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentProvider.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityEngine;
-using UnityEngine.Rendering;
-
-namespace UnityEditor.Rendering
-{
-    using IProvider = FilterWindow.IProvider;
-    using Element = FilterWindow.Element;
-    using GroupElement = FilterWindow.GroupElement;
-
-    class VolumeComponentProvider : IProvider
-    {
-        class VolumeComponentElement : Element
-        {
-            public Type type;
-
-            public VolumeComponentElement(int level, string label, Type type)
-            {
-                this.level = level;
-                this.type = type;
-                // TODO: Add support for custom icons
-                content = new GUIContent(label);
-            }
-        }
-
-        class PathNode : IComparable<PathNode>
-        {
-            public List<PathNode> nodes = new List<PathNode>();
-            public string name;
-            public Type type;
-
-            public int CompareTo(PathNode other)
-            {
-                return name.CompareTo(other.name);
-            }
-        }
-
-        public Vector2 position { get; set; }
-
-        VolumeProfile m_Target;
-        VolumeComponentListEditor m_TargetEditor;
-
-        public VolumeComponentProvider(VolumeProfile target, VolumeComponentListEditor targetEditor)
-        {
-            m_Target = target;
-            m_TargetEditor = targetEditor;
-        }
-
-        public void CreateComponentTree(List<Element> tree)
-        {
-            var currentPipeline = RenderPipelineManager.currentPipeline;
-            if (currentPipeline == null)
-            {
-                tree.Add(new GroupElement(0, "No SRP in use"));
-                return;
-            }
-
-            tree.Add(new GroupElement(0, "Volume Overrides"));
-
-            var volumeComponentTypesFiltered =
-                VolumeManager.GetSupportedVolumeComponents(currentPipeline.GetType());
-
-            if (volumeComponentTypesFiltered.Any())
-            {
-                var rootNode = new PathNode();
-
-                foreach (var (path, t) in volumeComponentTypesFiltered)
-                {
-                    // Skip components that have already been added to the volume
-                    if (m_Target.Has(t))
-                        continue;
-
-                    // Prep the categories & types tree
-                    AddNode(rootNode, path, t);
-                }
-
-                // Recursively add all elements to the tree
-                Traverse(rootNode, 1, tree);
-            }
-        }
-
-        public bool GoToChild(Element element, bool addIfComponent)
-        {
-            if (element is VolumeComponentElement volumeComponentElement)
-            {
-                m_TargetEditor.AddComponent(volumeComponentElement.type);
-                return true;
-            }
-
-            return false;
-        }
-
-        void AddNode(PathNode root, string path, Type type)
-        {
-            var current = root;
-            var parts = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
-
-            foreach (var part in parts)
-            {
-                var child = current.nodes.Find(x => x.name == part);
-
-                if (child == null)
-                {
-                    child = new PathNode { name = part, type = type };
-                    current.nodes.Add(child);
-                }
-
-                current = child;
-            }
-        }
-
-        void Traverse(PathNode node, int depth, List<Element> tree)
-        {
-            node.nodes.Sort();
-
-            foreach (var n in node.nodes)
-            {
-                if (n.nodes.Count > 0) // Group
-                {
-                    tree.Add(new GroupElement(depth, n.name));
-                    Traverse(n, depth + 1, tree);
-                }
-                else // Element
-                {
-                    tree.Add(new VolumeComponentElement(depth, n.name, n.type));
-                }
-            }
-        }
-    }
-}
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentTreeProvider.cs b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentTreeProvider.cs
new file mode 100644
index 00000000000..124253730c4
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentTreeProvider.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Rendering
+{
+    using IProvider = FilterWindow.IProvider;
+    using Element = FilterWindow.Element;
+    using GroupElement = FilterWindow.GroupElement;
+
+    /// <summary>
+    /// Build a tree for the add volume override menu.
+    ///
+    /// Don't show a volume if it is already in the stack
+    /// </summary>
+    class VolumeComponentTreeProvider : IProvider
+    {
+        internal class VolumeComponentElement : Element
+        {
+            public VolumeComponentType type;
+
+            public VolumeComponentElement(int level, string label, VolumeComponentType type)
+            {
+                this.level = level;
+                this.type = type;
+                // TODO: Add support for custom icons
+                content = new GUIContent(label);
+            }
+        }
+
+        [ExcludeFromCodeCoverage] // trivial
+        public Vector2 position { get; set; }
+
+        VolumeProfile m_Target;
+        VolumeComponentListEditor m_TargetEditor;
+        readonly VolumeComponentArchetype m_ArchetypeOverride;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="targetEditor"></param>
+        /// <param name="archetypeOverride">
+        /// Use this value to override which archetype to use to create the tree.
+        /// By default it will use the <see cref="VolumeComponentUserExperience.displayedArchetype"/>
+        /// </param>
+        public VolumeComponentTreeProvider(
+            [DisallowNull] VolumeProfile target,
+            [DisallowNull] VolumeComponentListEditor targetEditor,
+            [AllowNull] VolumeComponentArchetype archetypeOverride)
+        {
+            m_Target = target;
+            m_TargetEditor = targetEditor;
+            m_ArchetypeOverride = archetypeOverride;
+        }
+
+        public void CreateComponentTree([DisallowNull] List<Element> tree)
+        {
+            tree.Add(new GroupElement(0, "Volume Overrides"));
+
+            var archetype = m_ArchetypeOverride ?? VolumeComponentUserExperience.displayedArchetype;
+            if (!archetype.GetOrAddTreeProvider(out var extension))
+                return;
+
+            // Recursively add all elements to the tree
+            Traverse(extension.root, 1, tree);
+        }
+
+        public bool GoToChild([DisallowNull] Element element, bool addIfComponent)
+        {
+            if (element is VolumeComponentElement volumeComponentElement)
+            {
+                m_TargetEditor.AddComponent(volumeComponentElement.type);
+                return true;
+            }
+
+            return false;
+        }
+
+        void Traverse(
+            [DisallowNull] VolumeComponentArchetypeTreeProvider.PathNode node,
+            int depth,
+            [DisallowNull] List<Element> tree
+        )
+        {
+            node.nodes.Sort();
+
+            foreach (var n in node.nodes)
+            {
+                if (n.nodes.Count > 0) // Group
+                {
+                    tree.Add(new GroupElement(depth, n.name));
+                    Traverse(n, depth + 1, tree);
+                }
+                else if (!m_Target.Has(n.type.AsType())) // Element
+                {
+                    tree.Add(new VolumeComponentElement(depth, n.name, n.type));
+                }
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentTreeProvider.cs.meta b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentTreeProvider.cs.meta
new file mode 100644
index 00000000000..c4615026aca
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentTreeProvider.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ababffec716733b43bfcba44f30ef502
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentUserExperience.cs b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentUserExperience.cs
new file mode 100644
index 00000000000..28e908cae10
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentUserExperience.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using UnityEngine.Rendering;
+
+namespace UnityEditor.Rendering
+{
+    // Do not make this public
+    // Ongoing refactor will provide a better way to define components
+    // that can be added to a volume profile
+
+    // High level API bound to static resource/API. Hard to test, but used API should be tested
+    [ExcludeFromCodeCoverage]
+    internal static class VolumeComponentUserExperience
+    {
+        static readonly VolumeComponentContext k_DisplayedContext = new VolumeComponentContext();
+
+        [JetBrains.Annotations.NotNull]
+        public static VolumeComponentArchetype displayedArchetype
+        {
+            get
+            {
+                // workaround: at domain reload, the current pipeline is not set
+                //   so we must lazily check if it is the case to appropriately update
+                //   the archetypes.
+                OnPipelineChanged.UpdateDisplayContextIfRequired();
+                return k_DisplayedContext.contextualArchetype;
+            }
+        }
+
+        // High level API bound to static resource/API. Hard to test, but used API should be tested
+        [ExcludeFromCodeCoverage]
+        [InitializeOnLoad]
+        static class OnPipelineChanged
+        {
+            static Type s_LastPipelineType;
+            static VolumeComponentArchetype s_PreviousArchetype = null;
+
+            static OnPipelineChanged()
+            {
+                RenderPipelineManager.activeRenderPipelineTypeChanged += OnPipelineChangedCallback;
+                OnPipelineChangedCallback();
+            }
+
+            static void OnPipelineChangedCallback()
+            {
+                var renderPipeline = RenderPipelineManager.currentPipeline?.GetType();
+
+                if (s_PreviousArchetype != null)
+                {
+                    k_DisplayedContext.RemoveIncludeArchetype(s_PreviousArchetype);
+                    s_PreviousArchetype = null;
+                }
+
+                s_PreviousArchetype = VolumeComponentArchetype.FromFilterCached(IsExplicitlySupportedVolumeComponentFilter.FromType(renderPipeline));
+                k_DisplayedContext.AddIncludeArchetype(s_PreviousArchetype);
+                s_LastPipelineType = renderPipeline;
+            }
+
+            public static void UpdateDisplayContextIfRequired()
+            {
+                if (s_LastPipelineType != RenderPipelineManager.currentPipeline?.GetType())
+                    OnPipelineChangedCallback();
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentUserExperience.cs.meta b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentUserExperience.cs.meta
new file mode 100644
index 00000000000..44d03f81baf
--- /dev/null
+++ b/com.unity.render-pipelines.core/Editor/Volume/VolumeComponentUserExperience.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 14d9c8bd634cff44c89abd58bdb5712c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Debugging/DebugDisplaySettingsVolumes.cs b/com.unity.render-pipelines.core/Runtime/Debugging/DebugDisplaySettingsVolumes.cs
index f6e3ffc2675..dfc205a9095 100644
--- a/com.unity.render-pipelines.core/Runtime/Debugging/DebugDisplaySettingsVolumes.cs
+++ b/com.unity.render-pipelines.core/Runtime/Debugging/DebugDisplaySettingsVolumes.cs
@@ -12,13 +12,13 @@ namespace UnityEngine.Rendering
     public class DebugDisplaySettingsVolume : IDebugDisplaySettingsData
     {
         /// <summary>Current volume debug settings.</summary>
-        public IVolumeDebugSettings2 volumeDebugSettings { get; }
+        public IVolumeDebugSettings volumeDebugSettings { get; }
 
         /// <summary>
         /// Constructor with the settings
         /// </summary>
         /// <param name="volumeDebugSettings"></param>
-        public DebugDisplaySettingsVolume(IVolumeDebugSettings2 volumeDebugSettings)
+        public DebugDisplaySettingsVolume(IVolumeDebugSettings volumeDebugSettings)
         {
             this.volumeDebugSettings = volumeDebugSettings;
         }
@@ -54,7 +54,12 @@ public static DebugUI.EnumField CreateComponentSelector(DebugDisplaySettingsVolu
                 var componentNames = new List<GUIContent>() { Styles.none };
                 var componentValues = new List<int>() { componentIndex++ };
 
-                foreach (var type in data.volumeDebugSettings.volumeComponentsPathAndType)
+                if (!data.volumeDebugSettings.archetype.GetOrAddPathAndType(out var pathAndType))
+                {
+                    return default;
+                }
+
+                foreach (var type in pathAndType.volumeComponentPathAndTypes)
                 {
                     componentNames.Add(new GUIContent() { text = type.Item1 });
                     componentValues.Add(componentIndex++);
diff --git a/com.unity.render-pipelines.core/Runtime/Debugging/DebugUI.Panel.cs b/com.unity.render-pipelines.core/Runtime/Debugging/DebugUI.Panel.cs
index 8d506f78e11..cbea19d6d17 100644
--- a/com.unity.render-pipelines.core/Runtime/Debugging/DebugUI.Panel.cs
+++ b/com.unity.render-pipelines.core/Runtime/Debugging/DebugUI.Panel.cs
@@ -103,7 +103,7 @@ public void SetDirty()
             {
                 int numChildren = children.Count;
                 for (int i = 0; i < numChildren; i++)
-                    children[i].GenerateQueryPath();
+                    children[i]?.GenerateQueryPath();
 
                 onSetDirty(this);
             }
diff --git a/com.unity.render-pipelines.core/Runtime/Debugging/IVolumeDebugSettings.cs b/com.unity.render-pipelines.core/Runtime/Debugging/IVolumeDebugSettings.cs
index 1d2d9016fb8..5225fbe20fe 100644
--- a/com.unity.render-pipelines.core/Runtime/Debugging/IVolumeDebugSettings.cs
+++ b/com.unity.render-pipelines.core/Runtime/Debugging/IVolumeDebugSettings.cs
@@ -8,9 +8,7 @@ namespace UnityEngine.Rendering
 {
     /// <summary>
     /// Volume debug settings.
-    /// This variant is obsolete and kept only for not breaking user code. Use <see cref="IVolumeDebugSettings2"/> for all new usage.
     /// </summary>
-    [Obsolete("This variant is obsolete and kept only for not breaking user code. Use IVolumeDebugSettings2 for all new usage.", false)]
     public interface IVolumeDebugSettings
     {
         /// <summary>Selected component.</summary>
@@ -37,6 +35,8 @@ public interface IVolumeDebugSettings
         /// <summary>Type of the current component to debug.</summary>
         Type selectedComponentType { get; set; }
 
+        VolumeComponentArchetype archetype { get; }
+
         /// <summary>
         /// Obtains the Volumes
         /// </summary>
@@ -64,20 +64,4 @@ public interface IVolumeDebugSettings
         /// <returns>The weight of the volume</returns>
         float GetVolumeWeight(Volume volume);
     }
-
-    /// <summary>
-    /// Volume debug settings.
-    /// </summary>
-#pragma warning disable CS0618 // Type or member is obsolete
-    public interface IVolumeDebugSettings2 : IVolumeDebugSettings
-#pragma warning restore CS0618 // Type or member is obsolete
-    {
-        /// <summary>
-        /// Specifies the render pipelie
-        /// </summary>
-        Type targetRenderPipeline { get; }
-
-        /// <summary>List of Volume component types and their path</summary>
-        List<(string, Type)> volumeComponentsPathAndType { get; }
-    }
 }
diff --git a/com.unity.render-pipelines.core/Runtime/Debugging/VolumeDebugSettings.cs b/com.unity.render-pipelines.core/Runtime/Debugging/VolumeDebugSettings.cs
index 932d36a5866..3153f9206b0 100644
--- a/com.unity.render-pipelines.core/Runtime/Debugging/VolumeDebugSettings.cs
+++ b/com.unity.render-pipelines.core/Runtime/Debugging/VolumeDebugSettings.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using JetBrains.Annotations;
 using UnityEditor;
 
 namespace UnityEngine.Rendering
@@ -10,12 +11,15 @@ namespace UnityEngine.Rendering
     /// The volume settings
     /// </summary>
     /// <typeparam name="T">A <see cref="MonoBehaviour"/> with <see cref="IAdditionalData"/></typeparam>
-    public abstract partial class VolumeDebugSettings<T> : IVolumeDebugSettings2
+    public abstract partial class VolumeDebugSettings<T> : IVolumeDebugSettings
         where T : MonoBehaviour, IAdditionalData
     {
         /// <summary>Current volume component to debug.</summary>
         public int selectedComponent { get; set; } = 0;
 
+        [NotNull]
+        public abstract VolumeComponentArchetype archetype { get; }
+
         /// <summary>
         /// The current selected camera index
         /// </summary>
@@ -82,29 +86,24 @@ public IEnumerable<Camera> cameras
         /// <summary>Type of the current component to debug.</summary>
         public Type selectedComponentType
         {
-            get => volumeComponentsPathAndType[selectedComponent - 1].Item2;
+            get => archetype?.AsArray()[selectedComponent - 1].AsType();
             set
             {
-                var index = volumeComponentsPathAndType.FindIndex(t => t.Item2 == value);
+                var index = Array.FindIndex(archetype.AsArray(), t => t.AsType() == value);
                 if (index != -1)
                     selectedComponent = index + 1;
             }
         }
 
-        static List<(string, Type)> s_ComponentPathAndType;
-
-        /// <summary>List of Volume component types.</summary>
-        public List<(string, Type)> volumeComponentsPathAndType => s_ComponentPathAndType ??= VolumeManager.GetSupportedVolumeComponents(targetRenderPipeline);
-
         /// <summary>
-        /// The list of the additional camera datas
+        /// Specifies the render pipeline for this volume settings
         /// </summary>
-        protected static List<T> additionalCameraDatas { get; private set; } = new List<T>();
+        public abstract Type targetRenderPipeline { get; }
 
         /// <summary>
-        /// Specifies the render pipeline for this volume settings
+        /// The list of the additional camera datas
         /// </summary>
-        public abstract Type targetRenderPipeline { get; }
+        protected static List<T> additionalCameraDatas { get; private set; } = new List<T>();
 
         /// <summary>
         /// Register the camera for the Volume Debug.
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/ArrayExtensions.cs b/com.unity.render-pipelines.core/Runtime/Utilities/ArrayExtensions.cs
index 362ef355c4c..d33a21fa750 100644
--- a/com.unity.render-pipelines.core/Runtime/Utilities/ArrayExtensions.cs
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/ArrayExtensions.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Linq;
+using System.Text;
 using Unity.Collections;
 using UnityEngine.Jobs;
 
@@ -60,5 +62,26 @@ public static void ResizeArray<T>(ref T[] array, int capacity)
 
             Array.Resize<T>(ref array, capacity);
         }
+
+        /// <summary>
+        /// Create a debug string of an array of values
+        /// </summary>
+        /// <param name="values"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        internal static string ToDebugString<T>(this T[] values)
+        {
+            var sb = new StringBuilder();
+            sb.Append('[');
+            sb = values.Aggregate(sb, (acc, v) =>
+            {
+                if (acc.Length > 0)
+                    acc.Append('|');
+                acc.Append(v);
+                return acc;
+            });
+            sb.Append(']');
+            return sb.ToString();
+        }
     }
 }
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/Attributes.meta b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes.meta
new file mode 100644
index 00000000000..4c5c441632c
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: effc9bc6917f1054681b95e41dda0fb9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/DynamicTypeRelation.cs b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/DynamicTypeRelation.cs
new file mode 100644
index 00000000000..37369ebcc90
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/DynamicTypeRelation.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Stores a relationship between two types by using a dynamic storage.
+    ///
+    /// This is an alternative to static storage (in generic type) which may not be available for AOT platforms.
+    /// </summary>
+    public class DynamicTypeRelation
+    {
+        Dictionary<Type, HashSet<Type>> m_Dictionary = new Dictionary<Type, HashSet<Type>>();
+
+        /// <summary>
+        /// Set the value in a dictionary.
+        /// </summary>
+        /// <param name="subject"></param>
+        /// <param name="target"></param>
+        public void RegisterRelation([DisallowNull] Type subject, [DisallowNull] Type target)
+        {
+            if (!m_Dictionary.TryGetValue(subject, out var targets))
+            {
+                targets = new HashSet<Type>();
+                m_Dictionary.Add(subject, targets);
+            }
+
+            targets.Add(target);
+        }
+
+        /// <summary>
+        /// Set the value in a dictionary.
+        /// </summary>
+        public bool AreRelated<TSubject, TTarget>() => AreRelated(typeof(TSubject), typeof(TTarget));
+
+        /// <summary>
+        /// Are the provided type related?
+        /// </summary>
+        /// <param name="subject"></param>
+        /// <param name="target"></param>
+        /// <returns></returns>
+        public bool AreRelated([DisallowNull] Type subject, [DisallowNull] Type target)
+        {
+            var hasRelations = m_Dictionary.TryGetValue(subject, out var targets);
+            return hasRelations && targets.Contains(target);
+        }
+
+        /// <summary>
+        /// Does <typeparamref name="TSubject"/> have a relationship as a subject?
+        /// </summary>
+        /// <returns></returns>
+        public bool HasRelations<TSubject>() => HasRelations(typeof(TSubject));
+
+        /// <summary>
+        /// Does <paramref name="subject"/> have a relationship as a subject?
+        /// </summary>
+        /// <param name="subject"></param>
+        /// <returns></returns>
+        public bool HasRelations([DisallowNull] Type subject)
+        {
+            return m_Dictionary.ContainsKey(subject);
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/DynamicTypeRelation.cs.meta b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/DynamicTypeRelation.cs.meta
new file mode 100644
index 00000000000..c77025b9795
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/DynamicTypeRelation.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01ed70e17ef548248b1e51eff5fe49f4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/SupportedOnAttribute.cs b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/SupportedOnAttribute.cs
new file mode 100644
index 00000000000..7d8504c3521
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/SupportedOnAttribute.cs
@@ -0,0 +1,229 @@
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+
+// Note: This is safe for AOT platforms:
+//  - If you use the object based API, it will fallback on a in memory dictionary
+//  - If you use the generic API, the AOT compiler will pick up the associated classes and include them into the build.
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    ///     Use this attribute to specify that a type is compatible with another.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+    [ExcludeFromCodeCoverage] // Trivial constructor and accessor
+    public class SupportedOnAttribute : Attribute
+    {
+        /// <summary>
+        ///     Constructor of the attribute.
+        /// </summary>
+        /// <param name="subject">Which type will support <paramref name="target" />.</param>
+        /// <param name="target">Defines what to support.</param>
+        public SupportedOnAttribute(Type target)
+        {
+            this.target = target;
+        }
+
+        public Type target { get; }
+    }
+
+    /// <summary>
+    ///     Utilities to query the IsSupported relation.
+    /// </summary>
+    public static class IsSupportedOn
+    {
+        [ExcludeFromCodeCoverage] // Can't test static constructor and trivial
+        static IsSupportedOn()
+        {
+            if (!SupportedOnAttributeSetter.isLoaded)
+                Debug.LogWarning("IsSupportedOn is not loaded.");
+        }
+
+        static DynamicTypeRelation s_Relations = new DynamicTypeRelation();
+
+        /// <summary>
+        ///     Is <typeparamref name="TSubject" /> supported by  <typeparamref name="TTarget" />?.
+        ///     This is 10x faster than querying dynamically.
+        ///     See <see cref="IsSupportedOn{TSubject,TTarget}.IsImplicit" />.
+        /// </summary>
+        /// <typeparam name="TSubject">Which type will support <typeparamref name="TTarget" />.</typeparam>
+        /// <typeparam name="TTarget">Defines what to support.</typeparam>
+        /// <returns>Is <typeparamref name="TSubject" /> supported by  <typeparamref name="TTarget" />?.</returns>
+        public static bool IsSupportedBy<TSubject, TTarget>()
+        {
+            return IsSupportedOn<TSubject, TTarget>.IsSupported;
+        }
+
+        /// <summary>
+        ///     Is <typeparamref name="TSubject" /> explicitly supported by  <typeparamref name="TTarget" />?.
+        ///     This is 10x faster than querying dynamically.
+        ///     See <see cref="IsSupportedOn{TSubject,TTarget}.IsImplicit" />.
+        /// </summary>
+        /// <typeparam name="TSubject">Which type will support <typeparamref name="TTarget" />.</typeparam>
+        /// <typeparam name="TTarget">Defines what to support.</typeparam>
+        /// <returns>Is <typeparamref name="TSubject" /> supported by  <typeparamref name="TTarget" />?.</returns>
+        public static bool IsExplicitlySupportedBy<TSubject, TTarget>()
+        {
+            return IsSupportedOn<TSubject, TTarget>.IsExplicit;
+        }
+
+        /// <summary>
+        ///     Does <typeparamref name="TSubject" /> explicitly support another type?
+        /// </summary>
+        /// <typeparam name="TSubject">Does it explicitly support another type?</typeparam>
+        /// <returns>Does <typeparamref name="TSubject" /> explicitly support another type?</returns>
+        public static bool HasExplicitSupport<TSubject>()
+        {
+            return HasIsSupportedOn<TSubject>.Value;
+        }
+
+        /// <summary>
+        ///     Set the value in the static types
+        /// </summary>
+        /// <param name="subject">Which type will support <paramref name="target" />.</param>
+        /// <param name="target">Defines what to support.</param>
+        internal static void RegisterStaticRelation([DisallowNull] Type subject, [DisallowNull] Type target)
+        {
+            // Note: Null Ref for types.
+            //   We fetch an API that is defined below, we fully own the type definition.
+            //   So there must be no situation where the properties are not found.
+
+            var hasIsSupportedOn = typeof(HasIsSupportedOn<>).MakeGenericType(subject);
+
+            // ReSharper disable once PossibleNullReferenceException
+            hasIsSupportedOn
+                .GetProperty(nameof(HasIsSupportedOn<bool>.Value), BindingFlags.Static | BindingFlags.Public)
+                .SetValue(null, true);
+
+            var isSupportedOn = typeof(IsSupportedOn<,>).MakeGenericType(subject, target);
+
+            // ReSharper disable once PossibleNullReferenceException
+            isSupportedOn
+                .GetProperty(nameof(IsSupportedOn<bool, bool>.IsExplicit), BindingFlags.Static | BindingFlags.Public)
+                .SetValue(null, true);
+        }
+
+        /// <summary>
+        ///     Set the value in a dictionary.
+        ///     Note for AOT platforms: it may be required to use the dynamic backend because using generic structs
+        ///     require JIT.
+        /// </summary>
+        /// <param name="subject">Which type will support <paramref name="target" />.</param>
+        /// <param name="target">Defines what to support.</param>
+        // Defer implementation to `s_Relations.RegisterRelation(subject, target);` which is covered
+        [ExcludeFromCodeCoverage]
+        internal static void RegisterDynamicRelation([DisallowNull] Type subject, [DisallowNull] Type target)
+        {
+            s_Relations.RegisterRelation(subject, target);
+        }
+
+        /// <summary>
+        ///     Is <paramref name="subject" /> supported by  <paramref name="target" />?
+        /// </summary>
+        /// <param name="subject">Which type will support <paramref name="target" />.</param>
+        /// <param name="target">Defines what to support.</param>
+        /// <returns></returns>
+        public static bool IsSupportedBy([DisallowNull] Type subject, [DisallowNull] Type target)
+        {
+            return !s_Relations.HasRelations(subject) || s_Relations.AreRelated(subject, target);
+        }
+
+        /// <summary>
+        ///     Is <paramref name="subject" /> explicitly supported by  <paramref name="target" />?
+        /// </summary>
+        /// <param name="subject">Which type will support <paramref name="target" />.</param>
+        /// <param name="target">Defines what to support.</param>
+        /// <returns></returns>
+        public static bool IsExplicitlySupportedBy([DisallowNull] Type subject, [DisallowNull] Type target)
+        {
+            return s_Relations.AreRelated(subject, target);
+        }
+
+        /// <summary>
+        ///     Does <paramref name="subject" /> explicitly support another type?
+        /// </summary>
+        /// <param name="subject">Does it explicitly support another type?</param>
+        /// <returns></returns>
+        public static bool HasExplicitSupport([DisallowNull] Type subject)
+        {
+            return s_Relations.HasRelations(subject);
+        }
+    }
+
+    /// <summary>
+    ///     Use <see cref="Value" /> to know if <typeparamref name="TSubject" /> explicitly support at least one type.
+    /// </summary>
+    /// <typeparam name="TSubject">The type to query.</typeparam>
+
+    // ReSharper disable once UnusedTypeParameter
+    public struct HasIsSupportedOn<TSubject>
+    {
+        /// <summary>
+        ///     Use it to know if
+        ///     <typeparam name="TSubject" />
+        ///     explicitly support at least one type.
+        /// </summary>
+
+        // ReSharper disable once StaticMemberInGenericType
+        public static bool Value { get; set; } = false;
+    }
+
+    /// <summary>
+    ///     Use <see cref="IsImplicit" /> to know if <typeparamref name="TSubject" /> explicitly supports
+    ///     <typeparamref name="TTarget" />.
+    /// </summary>
+    /// <typeparam name="TSubject">The subject to query.</typeparam>
+    /// <typeparam name="TTarget">The type that defines what to support.</typeparam>
+
+    // ReSharper disable once UnusedTypeParameter
+    public struct IsSupportedOn<TSubject, TTarget>
+    {
+        [ExcludeFromCodeCoverage] // Trivial
+        public static bool IsExplicit { get; set; } = false;
+
+        /// <summary>
+        ///     Use it to know if <typeparamref name="TSubject" /> implicitly supports <typeparamref name="TTarget" />.
+        /// </summary>
+        public static bool IsImplicit => !HasIsSupportedOn<TSubject>.Value;
+
+        /// <summary>
+        ///     Use it to know if <typeparamref name="TSubject" />
+        ///     supports <typeparamref name="TTarget" /> implicitly or explicitly.
+        /// </summary>
+        public static bool IsSupported => IsExplicit || IsImplicit;
+    }
+
+    #region Registration Executor
+
+    /// <summary>
+    ///     Execute the registration code of the attribute.
+    ///     NOTE: This can be replaced by a code generation at compile time when available.
+    /// </summary>
+    static class SupportedOnAttributeSetter
+    {
+        public static bool isLoaded { get; private set; } = false;
+
+        static SupportedOnAttributeSetter()
+        {
+            // Note: Querying type with attribute with TypeCache is 4x faster that querying for assembly attribute
+            foreach (var type in TypeCache.GetTypesWithAttribute<SupportedOnAttribute>())
+            {
+                foreach (var attribute in type.GetCustomAttributes(typeof(SupportedOnAttribute)).Cast<SupportedOnAttribute>())
+                {
+                    if (attribute?.target == null)
+                        continue;
+
+                    IsSupportedOn.RegisterStaticRelation(type, attribute.target);
+                    IsSupportedOn.RegisterDynamicRelation(type, attribute.target);
+                }
+            }
+
+            isLoaded = true;
+        }
+    }
+
+    #endregion
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/SupportedOnAttribute.cs.meta b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/SupportedOnAttribute.cs.meta
new file mode 100644
index 00000000000..30ccef6a307
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/Attributes/SupportedOnAttribute.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff48f3001947bf14c98627ff2d07bdbc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/ExceptionUtilities.cs b/com.unity.render-pipelines.core/Runtime/Utilities/ExceptionUtilities.cs
new file mode 100644
index 00000000000..6399640696e
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/ExceptionUtilities.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Diagnostics;
+
+namespace UnityEngine.Rendering
+{
+    class StackTraceException : Exception
+    {
+        StackTrace m_StackTrace;
+
+        internal StackTraceException(Exception exception)
+            : base(exception.Message, exception)
+        {
+            m_StackTrace = new StackTrace(2, true);
+        }
+
+        public override string StackTrace => m_StackTrace.ToString();
+    }
+
+    static class ExceptionUtilities
+    {
+        /// <summary>
+        /// Wraps an exception to provide the stacktrace of its instantiation instead of its thrown location
+        /// </summary>
+        /// <param name="exception"></param>
+        /// <returns></returns>
+        public static Exception WithStackTrace(this Exception exception)
+        {
+            if (exception == null) return null;
+
+            return new StackTraceException(exception);
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Utilities/ExceptionUtilities.cs.meta b/com.unity.render-pipelines.core/Runtime/Utilities/ExceptionUtilities.cs.meta
new file mode 100644
index 00000000000..a8f52bec7d2
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Utilities/ExceptionUtilities.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5b74dafd21fe7834993d1cb5c51cfec1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/Internal.meta b/com.unity.render-pipelines.core/Runtime/Volume/Internal.meta
new file mode 100644
index 00000000000..8696685dc54
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/Internal.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a9ca8ba028a65b647881d2e8913f0a9a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/Internal/VolumeComponentDatabase.cs b/com.unity.render-pipelines.core/Runtime/Volume/Internal/VolumeComponentDatabase.cs
new file mode 100644
index 00000000000..3be572bd0ca
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/Internal/VolumeComponentDatabase.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// An immutable database of volume component types.
+    /// </summary>
+    public class VolumeComponentDatabase
+    {
+        /// <summary>
+        /// Database of all type loaded in memory.
+        ///
+        /// It must only depends on what is loaded in memory (thus it is a static).
+        /// </summary>
+        [NotNull]
+        public static VolumeComponentDatabase memoryDatabase { get; }
+
+        [ExcludeFromCodeCoverage]
+        static VolumeComponentDatabase()
+        {
+            // Get the types
+            var componentTypes = CoreUtils.GetAllTypesDerivedFrom<VolumeComponent>()
+                .Where(t => !t.IsAbstract).Select(VolumeComponentType.FromTypeUnsafe).ToArray();
+
+            // Call the init method if it exists.
+            StaticInitializeComponents(componentTypes);
+
+            memoryDatabase = new VolumeComponentDatabase(componentTypes);
+        }
+
+        internal static void StaticInitializeComponents(VolumeComponentType[] componentTypes)
+        {
+            const BindingFlags flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+            foreach (var type in componentTypes)
+            {
+                var initMethod = type.AsType().GetMethod("Init", flags);
+                if (initMethod != null)
+                {
+                    initMethod.Invoke(null, null);
+                }
+            }
+        }
+
+        public static VolumeComponentDatabase FromTypes([DisallowNull] VolumeComponentType[] types)
+            => new VolumeComponentDatabase(types);
+
+        VolumeComponentDatabase([DisallowNull] VolumeComponentType[] componentTypes) => this.componentTypes = componentTypes;
+
+        [NotNull]
+        public VolumeComponentType[] componentTypes { get; }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/Internal/VolumeComponentDatabase.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/Internal/VolumeComponentDatabase.cs.meta
new file mode 100644
index 00000000000..2fe9a60f02e
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/Internal/VolumeComponentDatabase.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2350e50e3bb860746910bea256dc56c9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.EditorOnly.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.EditorOnly.cs
index a8d9618bdbd..400ac3044c7 100644
--- a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.EditorOnly.cs
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.EditorOnly.cs
@@ -11,7 +11,19 @@ public bool TryGetRevertMethodForFieldName(SerializedProperty property, out Acti
         {
             revertMethod = property =>
             {
-                var defaultVolumeComponent = VolumeManager.instance.GetDefaultVolumeComponent(property.serializedObject.targetObject.GetType());
+                if (!VolumeComponentType.FromType(property.serializedObject.targetObject.GetType(), out var componentType))
+                    return;
+
+                var archetype = VolumeComponentArchetype.FromTypesCached(componentType);
+                if (!archetype.GetOrAddDefaultState(out var defaultState))
+                    return;
+
+                if (!defaultState.GetDefaultStateOf(componentType, out var defaultVolumeComponent, out var error))
+                {
+                    Debug.LogException(error);
+                    return;
+                }
+
                 Undo.RecordObject(property.serializedObject.targetObject, $"Revert property {property.propertyPath} from {property.serializedObject}");
                 SerializedObject serializedObject = new SerializedObject(defaultVolumeComponent);
                 var serializedProperty = serializedObject.FindProperty(property.propertyPath);
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.cs
index fa8aad49498..844a1833a90 100644
--- a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.cs
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponent.cs
@@ -35,6 +35,7 @@ public VolumeComponentMenu(string menu)
     /// This attribute allows you to add commands to the <strong>Add Override</strong> popup menu
     /// on Volumes and specify for which render pipelines will be supported
     /// </summary>
+    [Obsolete("Use SupportedOnAttribute to describe the dependency with VolumeComponentMenu attribute.")]
     public class VolumeComponentMenuForRenderPipeline : VolumeComponentMenu
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype.meta
new file mode 100644
index 00000000000..863f2cb333f
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6fb973ec4f3cb2444a2121dcea4684e8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/EverythingVolumeComponentFilter.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/EverythingVolumeComponentFilter.cs
new file mode 100644
index 00000000000..a2bc2957dd7
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/EverythingVolumeComponentFilter.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace UnityEngine.Rendering
+{
+    public sealed class EverythingVolumeComponentFilter : IFilter<VolumeComponentType>
+    {
+        public bool IsAccepted(VolumeComponentType subjectType) => true;
+
+        bool Equals(EverythingVolumeComponentFilter other) => true;
+
+        public bool Equals(IFilter<VolumeComponentType> other)
+        {
+            return other is EverythingVolumeComponentFilter filter && Equals(filter);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((EverythingVolumeComponentFilter)obj);
+        }
+
+        public override int GetHashCode() => 0;
+
+        public static bool operator ==(EverythingVolumeComponentFilter l, EverythingVolumeComponentFilter r)
+            => !ReferenceEquals(null, l) && l.Equals(r) || ReferenceEquals(null, r);
+        public static bool operator !=(EverythingVolumeComponentFilter l, EverythingVolumeComponentFilter r)
+            => !(l == r);
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/EverythingVolumeComponentFilter.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/EverythingVolumeComponentFilter.cs.meta
new file mode 100644
index 00000000000..d831f212c59
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/EverythingVolumeComponentFilter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c8cfcb7fb339f4943905be1eb32e86c5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Filter.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Filter.cs
new file mode 100644
index 00000000000..32d82119b0b
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Filter.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace UnityEngine.Rendering
+{
+    public sealed class IsSupportedVolumeComponentFilter : IFilter<VolumeComponentType>
+    {
+        [NotNull]
+        Type targetType { get; }
+
+        IsSupportedVolumeComponentFilter([DisallowNull] Type targetType)
+        {
+            this.targetType = targetType;
+        }
+
+        public bool IsAccepted(VolumeComponentType subjectType)
+        {
+            return IsSupportedOn.IsSupportedBy((Type)subjectType, targetType);
+        }
+
+        bool Equals(IsSupportedVolumeComponentFilter other)
+        {
+            return targetType == other.targetType;
+        }
+
+        public bool Equals(IFilter<VolumeComponentType> other)
+        {
+            return other is IsSupportedVolumeComponentFilter filter && Equals(filter);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            return obj.GetType() == this.GetType() && Equals((IsSupportedVolumeComponentFilter)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return (targetType != null ? targetType.GetHashCode() : 0);
+        }
+
+        public static IsSupportedVolumeComponentFilter FromType([DisallowNull] Type targetType)
+            => new IsSupportedVolumeComponentFilter(targetType);
+
+        public static bool operator ==(IsSupportedVolumeComponentFilter l, IsSupportedVolumeComponentFilter r)
+            => !ReferenceEquals(null, l) && l.Equals(r) || ReferenceEquals(null, r);
+        public static bool operator !=(IsSupportedVolumeComponentFilter l, IsSupportedVolumeComponentFilter r)
+            => !(l == r);
+    }
+
+    public sealed class IsExplicitlySupportedVolumeComponentFilter : IFilter<VolumeComponentType>
+    {
+        [NotNull]
+        Type targetType { get; }
+
+        IsExplicitlySupportedVolumeComponentFilter([DisallowNull] Type targetType)
+        {
+            this.targetType = targetType;
+        }
+
+        public bool IsAccepted(VolumeComponentType subjectType)
+        {
+            return IsSupportedOn.IsExplicitlySupportedBy((Type)subjectType, targetType);
+        }
+
+        bool Equals(IsExplicitlySupportedVolumeComponentFilter other)
+        {
+            return targetType == other.targetType;
+        }
+
+        public bool Equals(IFilter<VolumeComponentType> other)
+        {
+            return other is IsExplicitlySupportedVolumeComponentFilter filter && Equals(filter);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((IsExplicitlySupportedVolumeComponentFilter)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return (targetType != null ? targetType.GetHashCode() : 0);
+        }
+
+        public static IsExplicitlySupportedVolumeComponentFilter FromType([DisallowNull] Type targetType)
+            => new IsExplicitlySupportedVolumeComponentFilter(targetType);
+
+        public static bool operator ==(IsExplicitlySupportedVolumeComponentFilter l, IsExplicitlySupportedVolumeComponentFilter r)
+            => !ReferenceEquals(null, l) && l.Equals(r) || ReferenceEquals(null, r);
+        public static bool operator !=(IsExplicitlySupportedVolumeComponentFilter l, IsExplicitlySupportedVolumeComponentFilter r)
+            => !(l == r);
+    }
+
+    public sealed class IsVisibleVolumeComponentFilter : IFilter<VolumeComponentType>
+    {
+        static readonly IsVisibleVolumeComponentFilter k_True;
+        static readonly IsVisibleVolumeComponentFilter k_False;
+
+        [ExcludeFromCodeCoverage]
+        static IsVisibleVolumeComponentFilter()
+        {
+            k_True = new IsVisibleVolumeComponentFilter(true);
+            k_False = new IsVisibleVolumeComponentFilter(false);
+        }
+
+        readonly bool m_Visible;
+
+        public static IsVisibleVolumeComponentFilter FromIsVisible(bool isVisible)
+            => isVisible ? k_True : k_False;
+
+        public static bool IsVisible(VolumeComponentType type)
+            => !type.AsType().GetCustomAttributes(true)
+                .Any(attr => attr is HideInInspector or ObsoleteAttribute);
+
+        // private constructor only used in static properties to initialize true and false
+        [ExcludeFromCodeCoverage]
+        IsVisibleVolumeComponentFilter(bool visible)
+        {
+            m_Visible = visible;
+        }
+
+        public bool IsAccepted(VolumeComponentType subjectType)
+        {
+            var isVisible = IsVisible(subjectType);
+            return m_Visible && isVisible || !m_Visible && !isVisible;
+        }
+
+        bool Equals(IsVisibleVolumeComponentFilter other) => other.m_Visible == m_Visible;
+
+        public bool Equals(IFilter<VolumeComponentType> other)
+        {
+            return other is IsVisibleVolumeComponentFilter filter && Equals(filter);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((IsVisibleVolumeComponentFilter)obj);
+        }
+
+        public override int GetHashCode() => m_Visible.GetHashCode();
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Filter.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Filter.cs.meta
new file mode 100644
index 00000000000..5b50645d976
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Filter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5b6564a7b02a64b4da325caf43060d10
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/IFilter.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/IFilter.cs
new file mode 100644
index 00000000000..a8c878b40a8
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/IFilter.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Implement this interface to create a volume component filter.
+    ///
+    /// Use it with <see cref="VolumeComponentArchetype.FromFilterCached{TFilter}"/> to create a <see cref="VolumeComponentArchetype"/>.
+    /// </summary>
+    public interface IFilter<T> : IEquatable<IFilter<T>>
+    {
+        bool IsAccepted(T subjectType);
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/IFilter.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/IFilter.cs.meta
new file mode 100644
index 00000000000..ef01e9a6b76
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/IFilter.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fe45c37d90429ec4c9254ebf9040b18d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal.meta
new file mode 100644
index 00000000000..e4729cf928d
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cd03819c9d2a5594996eab35d0c2ab70
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.cs
new file mode 100644
index 00000000000..d099591708c
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.cs
@@ -0,0 +1,41 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    static class VolumeComponentTypeSetDefaultStateExtension
+    {
+        public static bool GetOrAddDefaultState(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetypeDefaultState extension)
+            => archetype.GetOrAddExtension<VolumeComponentArchetypeDefaultState, VolumeComponentArchetypeDefaultState.Factory>(out extension);
+
+        public static bool GetDefaultState(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetypeDefaultState extension)
+            => archetype.GetExtension<VolumeComponentArchetypeDefaultState, VolumeComponentArchetypeDefaultState.Factory>(out extension);
+    }
+    static class VolumeComponentTypeSetPathAndTypeExtension
+    {
+        public static bool GetOrAddPathAndType(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetypePathAndType extension)
+            => archetype.GetOrAddExtension<VolumeComponentArchetypePathAndType, VolumeComponentArchetypePathAndType.Factory>(out extension);
+
+        public static bool GetPathAndType(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetypePathAndType extension)
+            => archetype.GetExtension<VolumeComponentArchetypePathAndType, VolumeComponentArchetypePathAndType.Factory>(out extension);
+    }
+    static class VolumeComponentTypeSetTreeProviderExtension
+    {
+        public static bool GetOrAddTreeProvider(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetypeTreeProvider extension)
+            => archetype.GetOrAddExtension<VolumeComponentArchetypeTreeProvider, VolumeComponentArchetypeTreeProvider.Factory>(out extension);
+
+        public static bool GetTreeProvider(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetypeTreeProvider extension)
+            => archetype.GetExtension<VolumeComponentArchetypeTreeProvider, VolumeComponentArchetypeTreeProvider.Factory>(out extension);
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.cs.meta
new file mode 100644
index 00000000000..73ede42a4a4
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4ba0b496bf662cb40a4e0de74e524bc0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.tt b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.tt
new file mode 100644
index 00000000000..273e4053beb
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.tt
@@ -0,0 +1,55 @@
+<#@ template language="C#" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+<#
+    var extensions = new VolumeComponentTypeSetExtension[]
+    {
+        new VolumeComponentTypeSetExtension("DefaultState"),
+        new VolumeComponentTypeSetExtension("PathAndType"),
+        new VolumeComponentTypeSetExtension("TreeProvider"),
+    };
+
+    Write(extensions);
+#>
+}
+<#+
+    public struct VolumeComponentTypeSetExtension
+    {
+        public readonly string name;
+
+        public VolumeComponentTypeSetExtension(string name)
+        {
+            this.name = name;
+        }
+    }
+
+    public void Write(VolumeComponentTypeSetExtension extension)
+    {
+#>
+    static class VolumeComponentTypeSet<#+ Write(extension.name); #>Extension
+    {
+        public static bool GetOrAdd<#+ Write(extension.name); #>(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetype<#+ Write(extension.name); #> extension)
+            => archetype.GetOrAddExtension<VolumeComponentArchetype<#+ Write(extension.name); #>, VolumeComponentArchetype<#+ Write(extension.name); #>.Factory>(out extension);
+
+        public static bool Get<#+ Write(extension.name); #>(
+            [DisallowNull] this VolumeComponentArchetype archetype,
+            [NotNullWhen(true)] out VolumeComponentArchetype<#+ Write(extension.name); #> extension)
+            => archetype.GetExtension<VolumeComponentArchetype<#+ Write(extension.name); #>, VolumeComponentArchetype<#+ Write(extension.name); #>.Factory>(out extension);
+    }
+<#+
+    }
+
+    public void Write(params VolumeComponentTypeSetExtension[] extensions)
+    {
+        foreach (var extension in extensions)
+        {
+            Write(extension);
+        }
+    }
+#>
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.tt.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.tt.meta
new file mode 100644
index 00000000000..9fc598bb239
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/ExtensionUtilities.tt.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ba3590fc8a12402a81e37ce51a9accb5
+timeCreated: 1639571142
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeDefaultState.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeDefaultState.cs
new file mode 100644
index 00000000000..16b5582dc03
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeDefaultState.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using JetBrains.Annotations;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Manages the default data set of the volume components
+    /// </summary>
+    class VolumeComponentArchetypeDefaultState : VolumeComponentArchetypeExtension
+    {
+        public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeComponentArchetypeDefaultState>
+        {
+            [return: System.Diagnostics.CodeAnalysis.NotNull]
+            public VolumeComponentArchetypeDefaultState Create([DisallowNull] VolumeComponentArchetype volumeComponentArchetype)
+            {
+                var componentsDefaultState = volumeComponentArchetype.AsArray()
+                    .Select(type => (VolumeComponent)ScriptableObject.CreateInstance(type.AsType())).ToArray();
+
+                return new VolumeComponentArchetypeDefaultState(componentsDefaultState);
+            }
+        }
+        VolumeComponent[] componentsDefaultState { get; }
+
+        VolumeComponentArchetypeDefaultState(VolumeComponent[] componentsDefaultState)
+        {
+            this.componentsDefaultState = componentsDefaultState;
+        }
+
+        [MustUseReturnValue]
+        public bool GetDefaultStateOf(
+            [DisallowNull] VolumeComponentType type,
+            [NotNullWhen(true)] out VolumeComponent instance,
+            [NotNullWhen(false)] out Exception error
+        )
+        {
+            foreach (var volumeComponent in componentsDefaultState)
+            {
+                if (volumeComponent.GetType() == type.AsType())
+                {
+                    instance = volumeComponent;
+                    error = default;
+                    return true;
+                }
+            }
+
+            instance = default;
+            error = new ArgumentException($"Type was not found in archetype {type.AsType().Name}");
+            return false;
+        }
+
+        // Faster version of OverrideData to force replace values in the global state
+        public void ReplaceData([DisallowNull] VolumeStack stack)
+        {
+            foreach (var component in componentsDefaultState)
+            {
+                var target = stack.GetComponent(component.GetType());
+                var count = component.parameters.Count;
+
+                for (var i = 0; i < count; i++)
+                {
+                    if (target.parameters[i] != null)
+                    {
+                        target.parameters[i].overrideState = false;
+                        target.parameters[i].SetValue(component.parameters[i]);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeDefaultState.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeDefaultState.cs.meta
new file mode 100644
index 00000000000..46c12957afe
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeDefaultState.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 750f544fd77df6645903431b919df423
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeExtension.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeExtension.cs
new file mode 100644
index 00000000000..de2fd6a1dde
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeExtension.cs
@@ -0,0 +1,19 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Implement this class to extract more data about volume components.
+    ///
+    /// The purpose is to extract immutable data from the volume component set.
+    /// </summary>
+    abstract class VolumeComponentArchetypeExtension
+    {
+    }
+
+    interface IVolumeComponentArchetypeExtensionFactory<T>
+        where T : VolumeComponentArchetypeExtension
+    {
+        [return: NotNull] T Create([DisallowNull] VolumeComponentArchetype volumeComponentArchetype);
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeExtension.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeExtension.cs.meta
new file mode 100644
index 00000000000..cb75f497933
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeExtension.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8577e71509d2e6048aa5fccb167a6dbe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypePathAndType.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypePathAndType.cs
new file mode 100644
index 00000000000..93cd75dad55
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypePathAndType.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Extract volume components paths.
+    ///
+    /// Discards components that have:
+    /// * <see cref="HideInInspector"/> attribute
+    /// * <see cref="ObsoleteAttribute"/> attribute
+    /// </summary>
+    class VolumeComponentArchetypePathAndType : VolumeComponentArchetypeExtension
+    {
+        public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeComponentArchetypePathAndType>
+        {
+            struct BuiltinRenderPipeline { }
+
+            [return: NotNull]
+            public VolumeComponentArchetypePathAndType Create([DisallowNull] VolumeComponentArchetype volumeComponentArchetype)
+            {
+                var currentPipeline = RenderPipelineManager.currentPipeline?.GetType() ?? typeof(BuiltinRenderPipeline);
+                var types = volumeComponentArchetype.AsArray();
+
+                var componentPathAndTypes = new List<(string path, VolumeComponentType type)>();
+
+                // filter types based on attributes
+                foreach (var type in types)
+                {
+                    var path = string.Empty;
+                    var attrs = type.AsType().GetCustomAttributes(false);
+                    var skipComponent = !IsSupportedOn.IsSupportedBy((Type)type, currentPipeline);
+                    if (skipComponent)
+                        continue;
+
+                    // Look for the attributes of this volume component and decide how is added and if it needs to be skipped
+                    var isSkipped = false;
+                    foreach (var attr in attrs)
+                    {
+                        switch (attr)
+                        {
+                            case VolumeComponentMenu attrMenu:
+                            {
+                                path = attrMenu.menu;
+                                break;
+                            }
+                            case HideInInspector:
+                            case ObsoleteAttribute:
+                                isSkipped = true;
+                                break;
+                        }
+
+                        if (isSkipped)
+                            break;
+                    }
+                    if (isSkipped)
+                        continue;
+#if UNITY_EDITOR
+
+                    // If no attribute or in case something went wrong when grabbing it, fallback to a
+                    // beautified class name
+                    if (string.IsNullOrEmpty(path))
+                        path = UnityEditor.ObjectNames.NicifyVariableName(type.AsType().Name);
+#endif
+
+                    componentPathAndTypes.Add((path, type));
+                }
+
+                return new VolumeComponentArchetypePathAndType(componentPathAndTypes);
+            }
+        }
+
+        VolumeComponentArchetypePathAndType(List<(string path, VolumeComponentType type)> componentPathAndTypes)
+        {
+            volumeComponentPathAndTypes = componentPathAndTypes;
+        }
+
+        [NotNull]
+        public IReadOnlyList<(string path, VolumeComponentType type)> volumeComponentPathAndTypes { get; }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypePathAndType.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypePathAndType.cs.meta
new file mode 100644
index 00000000000..8f1c0fc3934
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypePathAndType.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f0b58a4fd605e1e489a772c43c909536
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeTreeProvider.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeTreeProvider.cs
new file mode 100644
index 00000000000..86e1b4993d5
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeTreeProvider.cs
@@ -0,0 +1,115 @@
+#if UNITY_EDITOR
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Extracts the tree structure to display for the add volume menu.
+    /// </summary>
+    class VolumeComponentArchetypeTreeProvider : VolumeComponentArchetypeExtension
+    {
+        public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeComponentArchetypeTreeProvider>
+        {
+            [return: NotNull]
+            public VolumeComponentArchetypeTreeProvider Create([DisallowNull] VolumeComponentArchetype volumeComponentArchetype)
+            {
+                var root = new PathNode(null, default);
+
+                if (volumeComponentArchetype.GetOrAddPathAndType(out var extension))
+                {
+                    // Build the tree
+                    if (extension.volumeComponentPathAndTypes.Count > 0)
+                    {
+                        foreach (var (path, t) in extension.volumeComponentPathAndTypes)
+                        {
+                            // Prep the categories & types tree
+                            AddNode(root, path, t);
+                        }
+                    }
+                }
+                return new VolumeComponentArchetypeTreeProvider(root);
+            }
+
+            static void AddNode(PathNode root, string path, VolumeComponentType type)
+            {
+                var current = root;
+                var parts = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
+
+                for (int i = 0; i < parts.Length; i++)
+                {
+                    var part = parts[i];
+                    var child = current.nodes.Find(x => x.name == part);
+
+                    if (child == null)
+                    {
+                        child = new PathNode(part, i == parts.Length - 1 ? type : default);
+                        current.nodes.Add(child);
+                    }
+
+                    current = child;
+                }
+            }
+        }
+
+        internal class PathNode : IEquatable<PathNode>, IComparable<PathNode>
+        {
+            public List<PathNode> nodes { get; } = new List<PathNode>();
+            public string name { get; }
+            public VolumeComponentType type { get; }
+
+            /// <summary>
+            /// String used to compare nodes
+            /// </summary>
+            string comparedString => $"{name}{type}";
+
+            public PathNode(string name, VolumeComponentType type)
+            {
+                this.name = name;
+                this.type = type;
+            }
+
+            public bool Equals(PathNode other)
+            {
+                if (ReferenceEquals(null, other)) return false;
+                if (ReferenceEquals(this, other)) return true;
+                return name == other.name && type.Equals(other.type);
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                if (ReferenceEquals(this, obj)) return true;
+                if (obj.GetType() != this.GetType()) return false;
+                return Equals((PathNode) obj);
+            }
+
+            public override int GetHashCode()
+            {
+                return HashCode.Combine(name, type);
+            }
+
+            public static bool operator ==(PathNode l, PathNode r) => l?.Equals(r) ?? ReferenceEquals(null, r);
+            public static bool operator !=(PathNode l, PathNode r) => !(l?.Equals(r) ?? ReferenceEquals(null, r));
+
+            public int CompareTo(PathNode other)
+            {
+                if (ReferenceEquals(this, other)) return 0;
+                if (ReferenceEquals(null, other)) return 1;
+                return string.Compare(comparedString, other.comparedString, StringComparison.Ordinal);
+            }
+        }
+
+        [NotNull]
+        public PathNode root { get; }
+
+        VolumeComponentArchetypeTreeProvider([DisallowNull] PathNode rootArg)
+        {
+            root = rootArg;
+        }
+    }
+}
+
+#endif
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeTreeProvider.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeTreeProvider.cs.meta
new file mode 100644
index 00000000000..e456e6476e3
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/Internal/VolumeComponentArchetypeTreeProvider.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2dedf1f0d05c4aa448c012546ff5a7e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentArchetype.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentArchetype.cs
new file mode 100644
index 00000000000..9d8cf41683f
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentArchetype.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using JetBrains.Annotations;
+
+using NotNullAttribute = System.Diagnostics.CodeAnalysis.NotNullAttribute;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Manage a set of volume component types.
+    ///
+    /// The managed set can be a subset defined by a filter.
+    ///
+    /// Immutable type
+    /// </summary>
+    public sealed class VolumeComponentArchetype : IEquatable<VolumeComponentArchetype>
+    {
+        [ExcludeFromCodeCoverage]
+        static class StaticMembers
+        {
+            public static readonly Dictionary<VolumeComponentDatabase, Dictionary<IFilter<VolumeComponentType>, VolumeComponentArchetype>> cacheByDatabaseByFilter
+                = new Dictionary<VolumeComponentDatabase, Dictionary<IFilter<VolumeComponentType>, VolumeComponentArchetype>>();
+
+            public static readonly Dictionary<HashSet<VolumeComponentType>, VolumeComponentArchetype> cacheByTypeSet =
+                new Dictionary<HashSet<VolumeComponentType>, VolumeComponentArchetype>();
+        }
+
+        VolumeComponentType[] typeArray { get; }
+        HashSet<VolumeComponentType> typeSet { get; }
+
+        Dictionary<(Type factory, Type extension), VolumeComponentArchetypeExtension> m_Extensions
+            = new Dictionary<(Type factory, Type extension), VolumeComponentArchetypeExtension>();
+
+        VolumeComponentArchetype([DisallowNull] params VolumeComponentType[] typeArray)
+        {
+            typeSet = typeArray.ToHashSet();
+            this.typeArray = typeSet.ToArray();
+        }
+
+        [return: NotNull]
+        public static VolumeComponentArchetype FromTypes([DisallowNull] params VolumeComponentType[] types)
+            => new VolumeComponentArchetype(types);
+
+        [return: NotNull]
+        public static VolumeComponentArchetype FromTypesCached([DisallowNull] params VolumeComponentType[] types)
+        {
+            using (HashSetPool<VolumeComponentType>.Get(out var typeSet))
+            {
+                typeSet.UnionWith(types);
+                if (!StaticMembers.cacheByTypeSet.TryGetValue(typeSet, out var instance))
+                {
+                    instance = FromTypes(types);
+                    StaticMembers.cacheByTypeSet.Add(new HashSet<VolumeComponentType>(typeSet), instance);
+                }
+
+                return instance;
+            }
+        }
+
+        [NotNull]
+        public static VolumeComponentArchetype Empty { get; } = new VolumeComponentArchetype();
+
+        [return: NotNull]
+        public static VolumeComponentArchetype FromFilterCached<TFilter>([DisallowNull] in TFilter filter, [AllowNull] VolumeComponentDatabase database = null)
+            where TFilter : IFilter<VolumeComponentType>
+        {
+            database ??= VolumeComponentDatabase.memoryDatabase;
+
+            if (!StaticMembers.cacheByDatabaseByFilter.TryGetValue(database, out var byFilter))
+            {
+                byFilter = new Dictionary<IFilter<VolumeComponentType>, VolumeComponentArchetype>();
+                StaticMembers.cacheByDatabaseByFilter.Add(database, byFilter);
+            }
+
+            if (!byFilter.TryGetValue(filter, out var set))
+            {
+                var baseComponentTypeArray = database.componentTypes
+                    .Where(filter.IsAccepted).ToArray();
+                set = new VolumeComponentArchetype(baseComponentTypeArray);
+                byFilter.Add(filter, set);
+            }
+
+            return set;
+        }
+
+        [return: NotNull]
+        public static VolumeComponentArchetype FromIncludeExclude(
+            [DisallowNull] IReadOnlyCollection<VolumeComponentArchetype> includes,
+            [DisallowNull] IReadOnlyCollection<VolumeComponentArchetype> excludes)
+        {
+            using (HashSetPool<VolumeComponentType>.Get(out var included))
+            using (HashSetPool<VolumeComponentType>.Get(out var excluded))
+            {
+                foreach (var include in includes)
+                    included.UnionWith(include.typeSet);
+                foreach (var exclude in excludes)
+                    excluded.UnionWith(exclude.typeSet);
+
+                included.ExceptWith(excluded);
+                return new VolumeComponentArchetype(included.ToArray());
+            }
+        }
+
+        [return: NotNull]
+        public VolumeComponentType[] AsArray() => typeArray;
+        public bool ContainsType(VolumeComponentType type) => typeSet.Contains(type);
+
+        [ExcludeFromCodeCoverage] // Trivial
+        public override string ToString()
+        {
+            return $"{nameof(VolumeComponentArchetype)}({typeArray.ToDebugString()})";
+        }
+
+        /// <summary>
+        /// Adds an extension if it does not exists
+        /// Get an extension it exists
+        /// </summary>
+        /// <param name="extension"></param>
+        /// <typeparam name="TExtension"></typeparam>
+        /// <typeparam name="TFactory"></typeparam>
+        /// <returns></returns>
+        [MustUseReturnValue]
+        internal bool GetOrAddExtension<TExtension, TFactory>([NotNullWhen(true)] out TExtension extension)
+            where TExtension : VolumeComponentArchetypeExtension
+            where TFactory : struct, IVolumeComponentArchetypeExtensionFactory<TExtension>
+        {
+            if (GetExtension<TExtension, TFactory>(out extension))
+                return true;
+
+            extension = new TFactory().Create(this);
+            m_Extensions.Add((typeof(TFactory), typeof(TExtension)), extension);
+            return true;
+        }
+
+        [MustUseReturnValue]
+        internal bool GetExtension<TExtension, TFactory>([NotNullWhen(true)] out TExtension extension)
+            where TExtension : VolumeComponentArchetypeExtension
+            where TFactory : struct, IVolumeComponentArchetypeExtensionFactory<TExtension>
+        {
+            if (m_Extensions.TryGetValue((typeof(TFactory), typeof(TExtension)), out var extensionBase))
+            {
+                extension = (TExtension)extensionBase;
+                return true;
+            }
+
+            extension = default;
+            return false;
+        }
+
+        public bool Equals(VolumeComponentArchetype other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return typeSet.SetEquals(other.typeSet);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return ReferenceEquals(this, obj) || obj is VolumeComponentArchetype other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return (typeSet != null ? typeSet.Aggregate(0, (acc, v) => acc + v.AsType().GetHashCode()) : 0);
+        }
+
+        public static bool operator ==(VolumeComponentArchetype l, VolumeComponentArchetype r) => l?.Equals(r) ?? ReferenceEquals(null, r) ;
+        public static bool operator !=(VolumeComponentArchetype l, VolumeComponentArchetype r) => !(l?.Equals(r) ?? ReferenceEquals(null, r));
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentArchetype.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentArchetype.cs.meta
new file mode 100644
index 00000000000..44e731acfb7
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentArchetype.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 72ae29fd8b9a98044a108d9badf3c5d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentType.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentType.cs
new file mode 100644
index 00000000000..0d2f66c1055
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentType.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace UnityEngine.Rendering
+{
+    public readonly struct VolumeComponentType : IEquatable<VolumeComponentType>
+    {
+        readonly Type m_Type;
+        VolumeComponentType(Type type) => m_Type = type;
+
+        public static bool FromType([AllowNull] Type type, out VolumeComponentType componentType)
+        {
+            if (type?.IsSubclassOf(typeof(VolumeComponent)) ?? false)
+            {
+                componentType = new VolumeComponentType(type);
+                return true;
+            }
+
+            componentType = default;
+            return false;
+        }
+
+        [return: NotNull]
+        public Type AsType() => m_Type;
+
+        /// <summary>
+        /// Safety: type must be non null and a subclass of <see cref="VolumeComponent"/>.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static unsafe VolumeComponentType FromTypeUnsafe([DisallowNull] Type type) => new VolumeComponentType(type);
+
+        public static explicit operator Type(in VolumeComponentType type) => type.m_Type;
+
+        public bool Equals(VolumeComponentType other)
+        {
+            return m_Type == other.m_Type;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is VolumeComponentType other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return (m_Type != null ? m_Type.GetHashCode() : 0);
+        }
+
+        [ExcludeFromCodeCoverage]
+        public override string ToString() => $"VolumeComponentType({m_Type?.Name})";
+
+        public static bool operator ==(in VolumeComponentType l, in VolumeComponentType r) => l.Equals(r);
+        public static bool operator !=(in VolumeComponentType l, in VolumeComponentType r) => !l.Equals(r);
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentType.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentType.cs.meta
new file mode 100644
index 00000000000..69d4384085c
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeComponentArchetype/VolumeComponentType.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4f7902e232ecedb4589088e0c87574de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.cs
index 8eb11f90364..c1778ddaf9d 100644
--- a/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.cs
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using UnityEngine.Assertions;
 
@@ -16,7 +15,7 @@ namespace UnityEngine.Rendering
     /// A global manager that tracks all the Volumes in the currently loaded Scenes and does all the
     /// interpolation work.
     /// </summary>
-    public sealed class VolumeManager
+    public sealed partial class VolumeManager
     {
         static readonly Lazy<VolumeManager> s_Instance = new Lazy<VolumeManager>(() => new VolumeManager());
 
@@ -25,24 +24,6 @@ public sealed class VolumeManager
         /// </summary>
         public static VolumeManager instance => s_Instance.Value;
 
-        /// <summary>
-        /// A reference to the main <see cref="VolumeStack"/>.
-        /// </summary>
-        /// <seealso cref="VolumeStack"/>
-        public VolumeStack stack { get; set; }
-
-        /// <summary>
-        /// The current list of all available types that derive from <see cref="VolumeComponent"/>.
-        /// </summary>
-        [Obsolete("Please use baseComponentTypeArray instead.")]
-        public IEnumerable<Type> baseComponentTypes
-        {
-            get => baseComponentTypeArray;
-            private set => baseComponentTypeArray = value.ToArray();
-        }
-
-        static readonly Dictionary<Type, List<(string, Type)>> s_SupportedVolumeComponentsForRenderPipeline = new();
-
         internal static List<(string, Type)> GetSupportedVolumeComponents(Type currentPipelineType)
         {
             if (s_SupportedVolumeComponentsForRenderPipeline.TryGetValue(currentPipelineType,
@@ -76,7 +57,7 @@ public IEnumerable<Type> baseComponentTypes
                         {
                             path = attrMenu.menu;
                             if (attrMenu is VolumeComponentMenuForRenderPipeline supportedOn)
-                                skipComponent |= !supportedOn.pipelineTypes.Contains(currentPipelineType);
+                                skipComponent |= Array.IndexOf(supportedOn.pipelineTypes, currentPipelineType) == -1;
                             break;
                         }
                         case HideInInspector attrHide:
@@ -109,10 +90,7 @@ public IEnumerable<Type> baseComponentTypes
                 .ToList();
         }
 
-        /// <summary>
-        /// The current list of all available types that derive from <see cref="VolumeComponent"/>.
-        /// </summary>
-        public Type[] baseComponentTypeArray { get; private set; }
+        static readonly Dictionary<Type, List<(string, Type)>> s_SupportedVolumeComponentsForRenderPipeline = new();
 
         // Max amount of layers available in Unity
         const int k_MaxLayerCount = 32;
@@ -126,95 +104,15 @@ public IEnumerable<Type> baseComponentTypes
         // Keep track of sorting states for layer masks
         readonly Dictionary<int, bool> m_SortNeeded;
 
-        // Internal list of default state for each component type - this is used to reset component
-        // states on update instead of having to implement a Reset method on all components (which
-        // would be error-prone)
-        readonly List<VolumeComponent> m_ComponentsDefaultState;
-
-        internal VolumeComponent GetDefaultVolumeComponent(Type volumeComponentType)
-        {
-            foreach (VolumeComponent component in m_ComponentsDefaultState)
-            {
-                if (component.GetType() == volumeComponentType)
-                    return component;
-            }
-
-            return null;
-        }
-
         // Recycled list used for volume traversal
         readonly List<Collider> m_TempColliders;
 
-        // The default stack the volume manager uses.
-        // We cache this as users able to change the stack through code and
-        // we want to be able to switch to the default one through the ResetMainStack() function.
-        VolumeStack m_DefaultStack = null;
-
         VolumeManager()
         {
             m_SortedVolumes = new Dictionary<int, List<Volume>>();
             m_Volumes = new List<Volume>();
             m_SortNeeded = new Dictionary<int, bool>();
             m_TempColliders = new List<Collider>(8);
-            m_ComponentsDefaultState = new List<VolumeComponent>();
-
-            ReloadBaseTypes();
-
-            m_DefaultStack = CreateStack();
-            stack = m_DefaultStack;
-        }
-
-        /// <summary>
-        /// Creates and returns a new <see cref="VolumeStack"/> to use when you need to store
-        /// the result of the Volume blending pass in a separate stack.
-        /// </summary>
-        /// <returns></returns>
-        /// <seealso cref="VolumeStack"/>
-        /// <seealso cref="Update(VolumeStack,Transform,LayerMask)"/>
-        public VolumeStack CreateStack()
-        {
-            var stack = new VolumeStack();
-            stack.Reload(baseComponentTypeArray);
-            return stack;
-        }
-
-        /// <summary>
-        /// Resets the main stack to be the default one.
-        /// Call this function if you've assigned the main stack to something other than the default one.
-        /// </summary>
-        public void ResetMainStack()
-        {
-            stack = m_DefaultStack;
-        }
-
-        /// <summary>
-        /// Destroy a Volume Stack
-        /// </summary>
-        /// <param name="stack">Volume Stack that needs to be destroyed.</param>
-        public void DestroyStack(VolumeStack stack)
-        {
-            stack.Dispose();
-        }
-
-        // This will be called only once at runtime and everytime script reload kicks-in in the
-        // editor as we need to keep track of any compatible component in the project
-        void ReloadBaseTypes()
-        {
-            m_ComponentsDefaultState.Clear();
-
-            // Grab all the component types we can find
-            baseComponentTypeArray = CoreUtils.GetAllTypesDerivedFrom<VolumeComponent>()
-                .Where(t => !t.IsAbstract).ToArray();
-
-            var flags = System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic;
-            // Keep an instance of each type to be used in a virtual lowest priority global volume
-            // so that we have a default state to fallback to when exiting volumes
-            foreach (var type in baseComponentTypeArray)
-            {
-                type.GetMethod("Init", flags)?.Invoke(null, null);
-                var inst = (VolumeComponent)ScriptableObject.CreateInstance(type);
-                m_ComponentsDefaultState.Add(inst);
-            }
         }
 
         /// <summary>
@@ -320,83 +218,14 @@ void OverrideData(VolumeStack stack, List<VolumeComponent> components, float int
                 if (!component.active)
                     continue;
 
+                if (!stack.archetype.ContainsType(VolumeComponentType.FromTypeUnsafe(component.GetType())))
+                    continue;
+
                 var state = stack.GetComponent(component.GetType());
                 component.Override(state, interpFactor);
             }
         }
 
-        // Faster version of OverrideData to force replace values in the global state
-        void ReplaceData(VolumeStack stack, List<VolumeComponent> components)
-        {
-            foreach (var component in components)
-            {
-                var target = stack.GetComponent(component.GetType());
-                int count = component.parameters.Count;
-
-                for (int i = 0; i < count; i++)
-                {
-                    if (target.parameters[i] != null)
-                    {
-                        target.parameters[i].overrideState = false;
-                        target.parameters[i].SetValue(component.parameters[i]);
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Checks the state of the base type library. This is only used in the editor to handle
-        /// entering and exiting of play mode and domain reload.
-        /// </summary>
-        [Conditional("UNITY_EDITOR")]
-        public void CheckBaseTypes()
-        {
-            // Editor specific hack to work around serialization doing funky things when exiting
-            if (m_ComponentsDefaultState == null || (m_ComponentsDefaultState.Count > 0 && m_ComponentsDefaultState[0] == null))
-                ReloadBaseTypes();
-        }
-
-        /// <summary>
-        /// Checks the state of a given stack. This is only used in the editor to handle entering
-        /// and exiting of play mode and domain reload.
-        /// </summary>
-        /// <param name="stack">The stack to check.</param>
-        [Conditional("UNITY_EDITOR")]
-        public void CheckStack(VolumeStack stack)
-        {
-            // The editor doesn't reload the domain when exiting play mode but still kills every
-            // object created while in play mode, like stacks' component states
-            var components = stack.components;
-
-            if (components == null)
-            {
-                stack.Reload(baseComponentTypeArray);
-                return;
-            }
-
-            foreach (var kvp in components)
-            {
-                if (kvp.Key == null || kvp.Value == null)
-                {
-                    stack.Reload(baseComponentTypeArray);
-                    return;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Updates the global state of the Volume manager. Unity usually calls this once per Camera
-        /// in the Update loop before rendering happens.
-        /// </summary>
-        /// <param name="trigger">A reference Transform to consider for positional Volume blending
-        /// </param>
-        /// <param name="layerMask">The LayerMask that the Volume manager uses to filter Volumes that it should consider
-        /// for blending.</param>
-        public void Update(Transform trigger, LayerMask layerMask)
-        {
-            Update(stack, trigger, layerMask);
-        }
-
         /// <summary>
         /// Updates the Volume manager and stores the result in a custom <see cref="VolumeStack"/>.
         /// </summary>
@@ -410,11 +239,11 @@ public void Update(VolumeStack stack, Transform trigger, LayerMask layerMask)
         {
             Assert.IsNotNull(stack);
 
-            CheckBaseTypes();
-            CheckStack(stack);
+            stack.CheckStack();
 
-            // Start by resetting the global state to default values
-            ReplaceData(stack, m_ComponentsDefaultState);
+            if (stack.archetype.GetOrAddDefaultState(out var defaultState))
+                // Start by resetting the global state to default values
+                defaultState.ReplaceData(stack);
 
             bool onlyGlobal = trigger == null;
             var triggerPos = onlyGlobal ? Vector3.zero : trigger.position;
@@ -571,22 +400,4 @@ static bool IsVolumeRenderedByCamera(Volume volume, Camera camera)
 #endif
         }
     }
-
-    /// <summary>
-    /// A scope in which a Camera filters a Volume.
-    /// </summary>
-    [Obsolete("VolumeIsolationScope is deprecated, it does not have any effect anymore.")]
-    public struct VolumeIsolationScope : IDisposable
-    {
-        /// <summary>
-        /// Constructs a scope in which a Camera filters a Volume.
-        /// </summary>
-        /// <param name="unused">Unused parameter.</param>
-        public VolumeIsolationScope(bool unused) { }
-
-        /// <summary>
-        /// Stops the Camera from filtering a Volume.
-        /// </summary>
-        void IDisposable.Dispose() { }
-    }
 }
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.deprecated.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.deprecated.cs
new file mode 100644
index 00000000000..41f719b7704
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.deprecated.cs
@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace UnityEngine.Rendering
+{
+    using UnityObject = UnityEngine.Object;
+
+    public sealed partial class VolumeManager
+    {
+        /// <summary>
+        /// A reference to the main <see cref="VolumeStack"/>.
+        /// </summary>
+        /// <seealso cref="VolumeStack"/>
+        [Obsolete("Use custom VolumeStack instances instead.")]
+        public VolumeStack stack { get; set; }
+
+        /// <summary>
+        /// The current list of all available types that derive from <see cref="VolumeComponent"/>.
+        /// </summary>
+        [Obsolete("Please use baseComponentTypeArray instead.")]
+        public IEnumerable<Type> baseComponentTypes
+        {
+            get => baseComponentTypeArray;
+            private set => Debug.LogWarning("VolumeManager.baseComponentTypes is obsolete, please use baseComponentTypeArray instead.");
+        }
+
+        /// <summary>
+        /// The current list of all available types that derive from <see cref="VolumeComponent"/>.
+        /// </summary>
+        [Obsolete("Use VolumeComponentArchetype to get the appropriate type array.")]
+        public Type[] baseComponentTypeArray => null;
+
+        /// <summary>
+        /// Destroy a Volume Stack
+        /// </summary>
+        /// <param name="stack">Volume Stack that needs to be destroyed.</param>
+        [Obsolete("Use VolumeStack.Dispose instead.")]
+        public void DestroyStack(VolumeStack stack)
+        {
+            stack.Dispose();
+        }
+
+        /// <summary>
+        /// Updates the global state of the Volume manager. Unity usually calls this once per Camera
+        /// in the Update loop before rendering happens.
+        /// </summary>
+        /// <param name="trigger">A reference Transform to consider for positional Volume blending
+        /// </param>
+        /// <param name="layerMask">The LayerMask that the Volume manager uses to filter Volumes that it should consider
+        /// for blending.</param>
+        [Obsolete("Use the overload with the stack parameter.")]
+        public void Update(Transform trigger, LayerMask layerMask)
+        {
+        }
+
+        /// <summary>
+        /// Checks the state of the base type library. This is only used in the editor to handle
+        /// entering and exiting of play mode and domain reload.
+        /// </summary>
+        [Conditional("UNITY_EDITOR")]
+        [Obsolete("Not required anymore")]
+        public void CheckBaseTypes()
+        {
+
+        }
+
+        /// <summary>
+        /// Checks the state of a given stack. This is only used in the editor to handle entering
+        /// and exiting of play mode and domain reload.
+        /// </summary>
+        /// <param name="stack">The stack to check.</param>
+        [Conditional("UNITY_EDITOR")]
+        [Obsolete("Use VolumeStack.CheckStack() instead.")]
+        public void CheckStack(VolumeStack stack)
+        {
+            stack.CheckStack();
+        }
+
+        /// <summary>
+        /// Creates and returns a new <see cref="VolumeStack"/> to use when you need to store
+        /// the result of the Volume blending pass in a separate stack.
+        /// </summary>
+        /// <returns></returns>
+        /// <seealso cref="VolumeStack"/>
+        /// <seealso cref="Update(VolumeStack,Transform,LayerMask)"/>
+        [Obsolete("Please use new VolumeStack(VolumeComponentArchetype) instead to create a stack.")]
+        public VolumeStack CreateStack()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Resets the main stack to be the default one.
+        /// Call this function if you've assigned the main stack to something other than the default one.
+        /// </summary>
+        [Obsolete("Not required")]
+        public void ResetMainStack()
+        {
+        }
+    }
+
+    /// <summary>
+    /// A scope in which a Camera filters a Volume.
+    /// </summary>
+    [Obsolete("VolumeIsolationScope is deprecated, it does not have any effect anymore.")]
+    public struct VolumeIsolationScope : IDisposable
+    {
+        /// <summary>
+        /// Constructs a scope in which a Camera filters a Volume.
+        /// </summary>
+        /// <param name="unused">Unused parameter.</param>
+        public VolumeIsolationScope(bool unused) { }
+
+        /// <summary>
+        /// Stops the Camera from filtering a Volume.
+        /// </summary>
+        void IDisposable.Dispose() { }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.deprecated.cs.meta b/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.deprecated.cs.meta
new file mode 100644
index 00000000000..c88653fa526
--- /dev/null
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeManager.deprecated.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4e2602b96d91d5b498f11a5fdeb281f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Runtime/Volume/VolumeStack.cs b/com.unity.render-pipelines.core/Runtime/Volume/VolumeStack.cs
index 3f556efb140..137fa55ceea 100644
--- a/com.unity.render-pipelines.core/Runtime/Volume/VolumeStack.cs
+++ b/com.unity.render-pipelines.core/Runtime/Volume/VolumeStack.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 
 namespace UnityEngine.Rendering
 {
@@ -11,24 +13,59 @@ namespace UnityEngine.Rendering
     /// </summary>
     public sealed class VolumeStack : IDisposable
     {
+        // Owner
         // Holds the state of _all_ component types you can possibly add on volumes
         internal Dictionary<Type, VolumeComponent> components;
+        internal VolumeComponentArchetype archetype { get; }
 
-        internal VolumeStack()
+        [return: NotNull]
+        public static VolumeStack FromArchetype([DisallowNull] VolumeComponentArchetype archetype) => new VolumeStack(archetype);
+
+        VolumeStack([DisallowNull] VolumeComponentArchetype archetype)
+        {
+            this.archetype = archetype;
+            components = new Dictionary<Type, VolumeComponent>();
+
+            Reload();
+        }
+
+        /// <summary>
+        /// Checks the state of a given stack. This is only used in the editor to handle entering
+        /// and exiting of play mode and domain reload.
+        /// </summary>
+        /// <param name="stack">The stack to check.</param>
+        [Conditional("UNITY_EDITOR")]
+        public void CheckStack()
         {
+            // The editor doesn't reload the domain when exiting play mode but still kills every
+            // object created while in play mode, like stacks' component states
+            if (components == null)
+            {
+                Reload();
+                return;
+            }
+
+            foreach (var kvp in components)
+            {
+                if (kvp.Key == null || kvp.Value == null)
+                {
+                    Reload();
+                    return;
+                }
+            }
         }
 
-        internal void Reload(Type[] baseTypes)
+        internal void Reload()
         {
             if (components == null)
                 components = new Dictionary<Type, VolumeComponent>();
             else
                 components.Clear();
 
-            foreach (var type in baseTypes)
+            foreach (var type in archetype.AsArray())
             {
-                var inst = (VolumeComponent)ScriptableObject.CreateInstance(type);
-                components.Add(type, inst);
+                var inst = (VolumeComponent)ScriptableObject.CreateInstance(type.AsType());
+                components.Add(type.AsType(), inst);
             }
         }
 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting.meta b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting.meta
new file mode 100644
index 00000000000..bb7f7fd22c9
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b9829968c244787b091c6bdd3a90d0f
+timeCreated: 1643618656
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll
new file mode 100644
index 00000000000..090c7567fc7
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a80d8d9587401872738f486ef3fb02d7da6d2fcb80bfe355f3798995721b907
+size 3079280
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.license.md b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.license.md
new file mode 100644
index 00000000000..41d6abebbe9
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.license.md
@@ -0,0 +1,55 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+    1. You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+    2. You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+    3. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+    4. If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+See FAQ for answers to frequently asked questions about this license.
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.license.md.meta b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.license.md.meta
new file mode 100644
index 00000000000..53890ef0fe6
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.license.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1c4e0be7ca9320144a50366326edeb23
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.meta b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.meta
new file mode 100644
index 00000000000..626560759a2
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FSharp.Core.dll.meta
@@ -0,0 +1,69 @@
+fileFormatVersion: 2
+guid: fba0e24df9cb39e4caf76f790e6978e2
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 1
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Editor: 0
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: x86_64
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: x86
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: x86_64
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll
new file mode 100644
index 00000000000..98f63b881c8
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa1147c42e306befa9b213e7b686a1bacc9d87f292edc53bf5811138ad5a079c
+size 827392
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.license.md b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.license.md
new file mode 100644
index 00000000000..61cea0d9ea4
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.license.md
@@ -0,0 +1,12 @@
+Copyright (c) 2008-2014, Kurt Schelfthout
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of FsCheck nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.license.md.meta b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.license.md.meta
new file mode 100644
index 00000000000..391e2f2557a
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.license.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a5d61eb0fbe4de147b1dd8aa86a3dd38
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.meta b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.meta
new file mode 100644
index 00000000000..8f844a2b8a8
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/FsCheck.dll.meta
@@ -0,0 +1,69 @@
+fileFormatVersion: 2
+guid: 1504189641f6f4e4a9e4abeb1fa8c9d7
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 1
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Editor: 0
+        Exclude Linux64: 1
+        Exclude OSXUniversal: 1
+        Exclude Win: 1
+        Exclude Win64: 1
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 0
+      settings:
+        CPU: x86_64
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: x86
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: x86_64
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/RandomPropertyTesting.cs b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/RandomPropertyTesting.cs
new file mode 100644
index 00000000000..bb5576dfd99
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/RandomPropertyTesting.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using FsCheck;
+using JetBrains.Annotations;
+
+namespace UnityEngine.Tests
+{
+    public static class UnityFsCheckExtensions
+    {
+        public static FsCheck.Random.StdGen ReplayConsistent
+            => FsCheck.Random.StdGen.NewStdGen(1145655947,296144285);
+
+        [CanBeNull]
+        public static FsCheck.Random.StdGen ReplayOverride = null;
+
+        [CanBeNull]
+        public static FsCheck.Random.StdGen ReplayOverrideFromEnv
+        {
+            get
+            {
+                var seedString = Environment.GetEnvironmentVariable("FSCHECK_SEED");
+                if (!ExtractSeedFromString(seedString, out var stdGen, out var error))
+                {
+                    if (error is FormatException)
+                    {
+                        Debug.LogException(error);
+                    }
+                }
+
+                return stdGen;
+            }
+        }
+
+        [MustUseReturnValue]
+        static bool ExtractSeedFromString(
+            [AllowNull] string seedAsString,
+            [NotNullWhen(true)] out FsCheck.Random.StdGen stdGen,
+            [NotNullWhen(false)] out Exception error
+            )
+        {
+            error = default;
+            stdGen = default;
+
+            if (string.IsNullOrEmpty(seedAsString))
+            {
+                error = new ArgumentException("Seed string is null or empty");
+                return false;
+            }
+
+            var ints = seedAsString.Split('|');
+            if (ints.Length != 2 || !int.TryParse(ints[0], out var s0) || !int.TryParse(ints[1], out var s1))
+            {
+                error = new FormatException("Seed must be formatted as `{int}|{int}`");
+                return false;
+            }
+
+            stdGen = FsCheck.Random.StdGen.NewStdGen(s0, s1);
+            return true;
+        }
+
+
+        public static Configuration ConsistentQuickThrowOnFailure
+        {
+            get
+            {
+                var configuration = Configuration.QuickThrowOnFailure;
+                configuration.Replay = ReplayConsistent;
+                return configuration;
+            }
+        }
+
+        // Replay depends on context settings
+        public static Configuration ContextualQuickThrowOnFailure
+        {
+            get
+            {
+                var configuration = Configuration.QuickThrowOnFailure;
+                configuration.Replay = ReplayOverrideFromEnv ?? (ReplayOverride ?? ReplayConsistent);
+                return configuration;
+            }
+        }
+
+        public static void ConsistentQuickCheckThrowOnFailure(this Property property)
+            => property.Check(ConsistentQuickThrowOnFailure);
+
+        // Replay depends on context settings
+        public static void ContextualQuickCheckThrowOnFailure(this Property property)
+            => property.Check(ContextualQuickThrowOnFailure);
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/RandomPropertyTesting.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/RandomPropertyTesting.cs.meta
new file mode 100644
index 00000000000..0ac2e95b46a
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/RandomPropertyTesting/RandomPropertyTesting.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4c4401720506405695e24b8a6128c13d
+timeCreated: 1643618713
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship.meta b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship.meta
new file mode 100644
index 00000000000..a25a1b28b97
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 61285485bb104554a61a29cad1ff4d00
+timeCreated: 1639562216
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/IsSupportedOn.cs b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/IsSupportedOn.cs
new file mode 100644
index 00000000000..a0b87b254fb
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/IsSupportedOn.cs
@@ -0,0 +1,74 @@
+using NUnit.Framework;
+
+namespace UnityEngine.Rendering.Tests
+{
+    [SupportedOn(typeof(__B))]
+    class __A { }
+    class __B { }
+    class __C { }
+
+
+    public class IsSupportedOnTest
+    {
+        [Test]
+        public void GenericAPI()
+        {
+            Assert.True(IsSupportedOn.HasExplicitSupport<__A>(), "A has explicit support.");
+            Assert.False(IsSupportedOn.HasExplicitSupport<__B>(), "B has no explicit support.");
+
+            Assert.True(IsSupportedOn.IsExplicitlySupportedBy<__A, __B>(), "A supports explicitly B.");
+            Assert.True(IsSupportedOn.IsSupportedBy<__A, __B>(), "A supports B.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy<__A, __C>(), "A don't supports explicitly B.");
+            Assert.False(IsSupportedOn.IsSupportedBy<__A, __C>(), "A don't supports implicitly B.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy<__B, __C>(), "B don't supports explicitly C.");
+            Assert.True(IsSupportedOn.IsSupportedBy<__B, __C>(), "B supports implicitly C.");
+        }
+
+        [Test]
+        public void DynamicAPI()
+        {
+            Assert.True(IsSupportedOn.IsExplicitlySupportedBy(typeof(__A), typeof(__B)), "A supports explicitly B.");
+            Assert.True(IsSupportedOn.IsSupportedBy(typeof(__A), typeof(__B)), "A supports B.");
+            Assert.True(IsSupportedOn.HasExplicitSupport(typeof(__A)), "A has explicit support.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy(typeof(__A), typeof(__C)), "A don't supports explicitly B.");
+            Assert.False(IsSupportedOn.IsSupportedBy(typeof(__A), typeof(__C)), "A don't supports implicitly B.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy(typeof(__B), typeof(__C)), "B don't supports explicitly C.");
+            Assert.True(IsSupportedOn.IsSupportedBy(typeof(__B), typeof(__C)), "B supports implicitly C.");
+        }
+    }
+
+    public class DynamicTypeRelations
+    {
+        [Test]
+        public void DynamicAPI()
+        {
+            var relations = new DynamicTypeRelation();
+            relations.RegisterRelation(typeof(__A), typeof(__B));
+
+            Assert.True(relations.HasRelations(typeof(__A)));
+            Assert.False(relations.HasRelations(typeof(__B)));
+
+            Assert.True(relations.AreRelated(typeof(__A), typeof(__B)), "A relates to B");
+            Assert.False(relations.AreRelated(typeof(__A), typeof(__C)), "A do not relate to C");
+            Assert.False(relations.AreRelated(typeof(__B), typeof(__C)), "B do not relate to C");
+        }
+
+        [Test]
+        public void GenericAPI()
+        {
+            var relations = new DynamicTypeRelation();
+            relations.RegisterRelation(typeof(__A), typeof(__B));
+
+            Assert.True(relations.HasRelations<__A>());
+            Assert.False(relations.HasRelations<__B>());
+
+            Assert.True(relations.AreRelated<Tests.__A, Tests.__B>(), "A relates to B");
+            Assert.False(relations.AreRelated<Tests.__A, Tests.__C>(), "A do not relate to C");
+            Assert.False(relations.AreRelated<Tests.__B, Tests.__C>(), "B do not relate to C");
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/IsSupportedOn.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/IsSupportedOn.cs.meta
new file mode 100644
index 00000000000..182bf2a2449
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/IsSupportedOn.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b55305a3cea34a89bcd5e2bb9a87cac9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/SupportedOnAttributeTests.cs b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/SupportedOnAttributeTests.cs
new file mode 100644
index 00000000000..4c52d874195
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/SupportedOnAttributeTests.cs
@@ -0,0 +1,25 @@
+using NUnit.Framework;
+using UnityEditor.Experimental.GraphView;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class SupportedOnAttributeTests
+    {
+        class TestA { }
+
+        class TestB { }
+
+        [Test]
+        public void RegisterStaticRelationSetStaticValues()
+        {
+            // No static registration performed
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy<TestA, TestB>());
+            Assert.False(IsSupportedOn.HasExplicitSupport<TestA>());
+
+            IsSupportedOn.RegisterStaticRelation(typeof(TestA), typeof(TestB));
+
+            Assert.True(IsSupportedOn.IsExplicitlySupportedBy<TestA, TestB>());
+            Assert.True(IsSupportedOn.HasExplicitSupport<TestA>());
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/SupportedOnAttributeTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/SupportedOnAttributeTests.cs.meta
new file mode 100644
index 00000000000..e31d49f16b2
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/TypeRelationship/SupportedOnAttributeTests.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0d2ab19a7c8e41b7ac75a962c06133b3
+timeCreated: 1639561980
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Unity.RenderPipelines.Core.Editor.Tests.asmdef b/com.unity.render-pipelines.core/Tests/Editor/Unity.RenderPipelines.Core.Editor.Tests.asmdef
index 0f2b4dfd156..51fa4b57458 100644
--- a/com.unity.render-pipelines.core/Tests/Editor/Unity.RenderPipelines.Core.Editor.Tests.asmdef
+++ b/com.unity.render-pipelines.core/Tests/Editor/Unity.RenderPipelines.Core.Editor.Tests.asmdef
@@ -1,5 +1,6 @@
 {
     "name": "Unity.RenderPipelines.Core.Editor.Tests",
+    "rootNamespace": "",
     "references": [
         "GUID:df380645f10b7bc4b97d4f5eb6303d95",
         "GUID:3eae0364be2026648bf74846acb8a731",
@@ -13,11 +14,14 @@
     "allowUnsafeCode": true,
     "overrideReferences": true,
     "precompiledReferences": [
-        "nunit.framework.dll"
+        "nunit.framework.dll",
+        "FSharp.Core.dll",
+        "FsCheck.dll"
     ],
     "autoReferenced": false,
     "defineConstraints": [
         "UNITY_INCLUDE_TESTS"
     ],
-    "versionDefines": []
+    "versionDefines": [],
+    "noEngineReferences": false
 }
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/ArbX.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/ArbX.cs
new file mode 100644
index 00000000000..a652d4bd0e1
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/ArbX.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using FsCheck;
+using Microsoft.FSharp.Core;
+using UnityEditor;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public static partial class ArbX
+    {
+        static readonly Type[] k_DefaultTypes = {
+            typeof(bool),
+            typeof(byte),
+            typeof(sbyte),
+            typeof(short),
+            typeof(ushort),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(ulong),
+            typeof(float),
+            typeof(double),
+            typeof(string), };
+
+        public class ArbitraryVolumeComponentType : Arbitrary<VolumeComponentType>
+        {
+            static VolumeComponentType[] s_Types = TestTypes.AllVolumeComponents
+                .Select(VolumeComponentType.FromTypeUnsafe)
+                .ToArray();
+
+            public override Gen<VolumeComponentType> Generator => Gen.Elements(s_Types);
+        }
+
+        public class ArbitraryVolumeComponentArchetype : Arbitrary<VolumeComponentArchetype>
+        {
+            public override Gen<VolumeComponentArchetype> Generator => Gen.Map(
+                (FSharpFunc<VolumeComponentType[], VolumeComponentArchetype>)VolumeComponentArchetype.FromTypes,
+                Gen.ArrayOf(Arbitraries.GetVolumeComponentType().Generator)
+            );
+        }
+
+        public partial class Arbitraries
+        {
+            public static Arbitrary<VolumeComponentType> GetVolumeComponentType()
+                => new ArbitraryVolumeComponentType();
+
+            public static Arbitrary<VolumeComponentArchetype> GetVolumeComponentArchetype()
+                => new ArbitraryVolumeComponentArchetype();
+        }
+
+        class ArbitraryType : Arbitrary<Type>
+        {
+            static Type[] s_Types = TestTypes.AllVolumeComponents.Take(20)
+                .Union(new Type[] { null })
+                .Union(k_DefaultTypes)
+                .ToArray();
+
+            public override Gen<Type> Generator => Gen.Elements(s_Types);
+        }
+
+        public static Arbitrary<Type> CreateTypeArbitrary() => new ArbitraryType();
+
+        public static void Register()
+        {
+            Arb.Register<Arbitraries>();
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/ArbX.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/ArbX.cs.meta
new file mode 100644
index 00000000000..5f62c209091
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/ArbX.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 25b8360d34da2fc4bb4edf840dc5d42a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.cs
new file mode 100644
index 00000000000..41acc42358f
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.cs
@@ -0,0 +1,305 @@
+using System;
+using System.Linq;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class SomeObject {}
+
+    partial class EqualityTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void IsSupportedVolumeComponentFilterEquality()
+        {
+            bool Property(VolumeComponentType l, VolumeComponentType r)
+            {
+                var l2 = IsSupportedVolumeComponentFilter.FromType(l.AsType());
+                var r2 = IsSupportedVolumeComponentFilter.FromType(r.AsType());
+
+                var expectsAreEquals = l.AsType() == r.AsType();
+                                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+                return result;
+            }
+
+            Prop.ForAll<VolumeComponentType, VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<VolumeComponentType>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+        [Test]
+        public void IsExplicitlySupportedVolumeComponentFilterEquality()
+        {
+            bool Property(VolumeComponentType l, VolumeComponentType r)
+            {
+                var l2 = IsExplicitlySupportedVolumeComponentFilter.FromType(l.AsType());
+                var r2 = IsExplicitlySupportedVolumeComponentFilter.FromType(r.AsType());
+
+                var expectsAreEquals = l.AsType() == r.AsType();
+                                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+                return result;
+            }
+
+            Prop.ForAll<VolumeComponentType, VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<VolumeComponentType>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+        [Test]
+        public void VolumeComponentTypeEquality()
+        {
+            bool Property(VolumeComponentType l, VolumeComponentType r)
+            {
+                var l2 = l;
+                var r2 = r;
+
+                var expectsAreEquals = l.AsType() == r.AsType();
+                                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+                return result;
+            }
+
+            Prop.ForAll<VolumeComponentType, VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<VolumeComponentType>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+        [Test]
+        public void IsVisibleVolumeComponentFilterEquality()
+        {
+            bool Property(bool l, bool r)
+            {
+                var l2 = IsVisibleVolumeComponentFilter.FromIsVisible(l);
+                var r2 = IsVisibleVolumeComponentFilter.FromIsVisible(r);
+
+                var expectsAreEquals = l == r;
+                                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+                return result;
+            }
+
+            Prop.ForAll<bool, bool>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<bool>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+        [Test]
+        public void VolumeComponentArchetypeEquality()
+        {
+            bool Property(VolumeComponentType[] l, VolumeComponentType[] r)
+            {
+                var l2 = VolumeComponentArchetype.FromTypes(l);
+                var r2 = VolumeComponentArchetype.FromTypes(r);
+
+                var expectsAreEquals = l.ToHashSet().SetEquals(r.ToHashSet());
+                                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+                return result;
+            }
+
+            Prop.ForAll<VolumeComponentType[], VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<VolumeComponentType[]>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+        [Test]
+        public void VolumeComponentArchetypeTreeProviderPathNodeEquality()
+        {
+            bool Property((string name, VolumeComponentType type) l, (string name, VolumeComponentType type) r)
+            {
+                var l2 = new VolumeComponentArchetypeTreeProvider.PathNode(l.name, l.type);
+                var r2 = new VolumeComponentArchetypeTreeProvider.PathNode(r.name, r.type);
+
+                var expectsAreEquals = (l.name == r.name && l.type == r.type);
+                                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+                return result;
+            }
+
+            Prop.ForAll<(string name, VolumeComponentType type), (string name, VolumeComponentType type)>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<(string name, VolumeComponentType type)>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+
+        [Test]
+        public void EverythingVolumeComponentFilterEquality()
+        {
+            var l2 = new EverythingVolumeComponentFilter();
+            var r2 = new EverythingVolumeComponentFilter();
+
+            var expectsAreEquals = true;
+                            var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+            Assert.True(result);
+        }
+    }
+}
+
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.cs.meta
new file mode 100644
index 00000000000..cc7f24a3b0e
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b61cf7ff79774794880f074af52cfdab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.tt b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.tt
new file mode 100644
index 00000000000..fa1d42035d3
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.tt
@@ -0,0 +1,156 @@
+<#@ template language="C#"
+#><#@ import namespace="System.Text"
+#><#@ import namespace="System.Collections.Generic"
+#>
+using System;
+using System.Linq;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class SomeObject {}
+
+    partial class EqualityTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+<# foreach (var test in equalityTests) Write(test); #>
+
+        [Test]
+        public void EverythingVolumeComponentFilterEquality()
+        {
+            var l2 = new EverythingVolumeComponentFilter();
+            var r2 = new EverythingVolumeComponentFilter();
+
+            var expectsAreEquals = true;
+            <# WriteEqualityCode(true); #>
+            Assert.True(result);
+        }
+    }
+}
+
+<#+
+    public struct EqualityTest
+    {
+        public string testName;
+        public string buildFromType;
+        public string constructor;
+        public string expectsAreEqual;
+        public bool addNullableTests;
+
+        public EqualityTest(string testName, string buildFromType, string constructor, string expectsAreEqual, bool addNullableTests)
+        {
+            this.testName = testName;
+            this.buildFromType = buildFromType;
+            this.constructor = constructor;
+            this.expectsAreEqual = expectsAreEqual;
+            this.addNullableTests = addNullableTests;
+        }
+    }
+
+    public void Write(EqualityTest test)
+    {
+        #>
+        [Test]
+        public void <#= test.testName #>()
+        {
+            bool Property(<#= test.buildFromType #> l, <#= test.buildFromType #> r)
+            {
+                var l2 = <#= string.Format(test.constructor, "l") #>;
+                var r2 = <#= string.Format(test.constructor, "r") #>;
+
+                var expectsAreEquals = <#= test.expectsAreEqual #>;
+                <#+ WriteEqualityCode(test.addNullableTests); #>
+                return result;
+            }
+
+            Prop.ForAll<<#= test.buildFromType #>, <#= test.buildFromType #>>(Property).ContextualQuickCheckThrowOnFailure();
+
+            // Enforce testing equality
+            var value = Arb.Generate<<#= test.buildFromType #>>().Eval(1, FsCheck.Random.StdGen.NewStdGen(0, 0));
+            Assert.IsTrue(Property(value, value));
+        }
+<#+
+    }
+
+    public void WriteEqualityCode(bool addNullableTests)
+    {
+#>
+                var areEquals = l2 == r2;
+                var areEquals2 = l2.Equals(r2);
+                var areEquals3 = l2.Equals((object)r2);
+                var areNotEquals4 = l2 != r2;
+
+                // The hashcode must be the same for identical values
+                var hashCodeEquals = expectsAreEquals && l2.GetHashCode() == r2.GetHashCode()
+                    || !expectsAreEquals;
+
+                // Check equal to itself
+                var isEqual = l2 == l2 && l2.GetHashCode() == l2.GetHashCode();
+
+                var nullableTest = false;
+<#+
+        if (addNullableTests)
+        {
+#>
+                r2 = null;
+                nullableTest = !l2.Equals(r2);
+<#+
+        }
+#>
+                var result = areEquals == areEquals2
+                    && areEquals == areEquals3
+                    && areEquals != areNotEquals4
+                    && hashCodeEquals
+                    && areEquals == expectsAreEquals
+                    && isEqual
+                    && !l2.Equals((object)null)
+                    && !l2.Equals((object)new SomeObject())
+                    && l2.Equals((object)l2);
+<#+
+    }
+
+    public static class Tests
+    {
+        public const string fromTypeConstructor = "{0}.FromType({{0}}.AsType())";
+        public static EqualityTest VolumeComponentFilter(string className, string constructor)
+            => new EqualityTest($"" +
+                $"{className}Equality",
+                "VolumeComponentType",
+                string.Format(constructor, className),
+                "l.AsType() == r.AsType()",
+                true);
+    }
+
+    EqualityTest[] equalityTests = new[]
+    {
+        Tests.VolumeComponentFilter("IsSupportedVolumeComponentFilter", Tests.fromTypeConstructor),
+        Tests.VolumeComponentFilter("IsExplicitlySupportedVolumeComponentFilter", Tests.fromTypeConstructor),
+        new EqualityTest("VolumeComponentTypeEquality",
+            "VolumeComponentType",
+            "{0}",
+            "l.AsType() == r.AsType()",
+            false),
+        new EqualityTest("IsVisibleVolumeComponentFilterEquality",
+            "bool",
+            "IsVisibleVolumeComponentFilter.FromIsVisible({0})",
+            "l == r",
+            true),
+        new EqualityTest("VolumeComponentArchetypeEquality",
+            "VolumeComponentType[]",
+            "VolumeComponentArchetype.FromTypes({0})",
+            "l.ToHashSet().SetEquals(r.ToHashSet())",
+            true),
+        new EqualityTest("VolumeComponentArchetypeTreeProviderPathNodeEquality",
+            "(string name, VolumeComponentType type)",
+            "new VolumeComponentArchetypeTreeProvider.PathNode({0}.name, {0}.type)",
+            "(l.name == r.name && l.type == r.type)",
+            true),
+    };
+#>
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.tt.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.tt.meta
new file mode 100644
index 00000000000..a3c667b633f
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/EqualityTests.tt.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e5060a85d51edd1429ad908b8ac69816
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.cs
new file mode 100644
index 00000000000..639379e0434
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.cs
@@ -0,0 +1,6661 @@
+using System;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public partial class TestTypes
+    {
+        public static Type[] AllVolumeComponents = new Type[] {
+            typeof(TestVolumeComponent0000),
+            typeof(TestVolumeComponent0001),
+            typeof(TestVolumeComponent0002),
+            typeof(TestVolumeComponent0003),
+            typeof(TestVolumeComponent0004),
+            typeof(TestVolumeComponent0005),
+            typeof(TestVolumeComponent0006),
+            typeof(TestVolumeComponent0007),
+            typeof(TestVolumeComponent0008),
+            typeof(TestVolumeComponent0009),
+            typeof(TestVolumeComponent0010),
+            typeof(TestVolumeComponent0011),
+            typeof(TestVolumeComponent0012),
+            typeof(TestVolumeComponent0013),
+            typeof(TestVolumeComponent0014),
+            typeof(TestVolumeComponent0015),
+            typeof(TestVolumeComponent0016),
+            typeof(TestVolumeComponent0017),
+            typeof(TestVolumeComponent0018),
+            typeof(TestVolumeComponent0019),
+            typeof(TestVolumeComponent0020),
+            typeof(TestVolumeComponent0021),
+            typeof(TestVolumeComponent0022),
+            typeof(TestVolumeComponent0023),
+            typeof(TestVolumeComponent0024),
+            typeof(TestVolumeComponent0025),
+            typeof(TestVolumeComponent0026),
+            typeof(TestVolumeComponent0027),
+            typeof(TestVolumeComponent0028),
+            typeof(TestVolumeComponent0029),
+            typeof(TestVolumeComponent0030),
+            typeof(TestVolumeComponent0031),
+            typeof(TestVolumeComponent0032),
+            typeof(TestVolumeComponent0033),
+            typeof(TestVolumeComponent0034),
+            typeof(TestVolumeComponent0035),
+            typeof(TestVolumeComponent0036),
+            typeof(TestVolumeComponent0037),
+            typeof(TestVolumeComponent0038),
+            typeof(TestVolumeComponent0039),
+            typeof(TestVolumeComponent0040),
+            typeof(TestVolumeComponent0041),
+            typeof(TestVolumeComponent0042),
+            typeof(TestVolumeComponent0043),
+            typeof(TestVolumeComponent0044),
+            typeof(TestVolumeComponent0045),
+            typeof(TestVolumeComponent0046),
+            typeof(TestVolumeComponent0047),
+            typeof(TestVolumeComponent0048),
+            typeof(TestVolumeComponent0049),
+            typeof(TestVolumeComponent0050),
+            typeof(TestVolumeComponent0051),
+            typeof(TestVolumeComponent0052),
+            typeof(TestVolumeComponent0053),
+            typeof(TestVolumeComponent0054),
+            typeof(TestVolumeComponent0055),
+            typeof(TestVolumeComponent0056),
+            typeof(TestVolumeComponent0057),
+            typeof(TestVolumeComponent0058),
+            typeof(TestVolumeComponent0059),
+            typeof(TestVolumeComponent0060),
+            typeof(TestVolumeComponent0061),
+            typeof(TestVolumeComponent0062),
+            typeof(TestVolumeComponent0063),
+            typeof(TestVolumeComponent0064),
+            typeof(TestVolumeComponent0065),
+            typeof(TestVolumeComponent0066),
+            typeof(TestVolumeComponent0067),
+            typeof(TestVolumeComponent0068),
+            typeof(TestVolumeComponent0069),
+            typeof(TestVolumeComponent0070),
+            typeof(TestVolumeComponent0071),
+            typeof(TestVolumeComponent0072),
+            typeof(TestVolumeComponent0073),
+            typeof(TestVolumeComponent0074),
+            typeof(TestVolumeComponent0075),
+            typeof(TestVolumeComponent0076),
+            typeof(TestVolumeComponent0077),
+            typeof(TestVolumeComponent0078),
+            typeof(TestVolumeComponent0079),
+            typeof(TestVolumeComponent0080),
+            typeof(TestVolumeComponent0081),
+            typeof(TestVolumeComponent0082),
+            typeof(TestVolumeComponent0083),
+            typeof(TestVolumeComponent0084),
+            typeof(TestVolumeComponent0085),
+            typeof(TestVolumeComponent0086),
+            typeof(TestVolumeComponent0087),
+            typeof(TestVolumeComponent0088),
+            typeof(TestVolumeComponent0089),
+            typeof(TestVolumeComponent0090),
+            typeof(TestVolumeComponent0091),
+            typeof(TestVolumeComponent0092),
+            typeof(TestVolumeComponent0093),
+            typeof(TestVolumeComponent0094),
+            typeof(TestVolumeComponent0095),
+            typeof(TestVolumeComponent0096),
+            typeof(TestVolumeComponent0097),
+            typeof(TestVolumeComponent0098),
+            typeof(TestVolumeComponent0099),
+            typeof(TestVolumeComponent0100),
+            typeof(TestVolumeComponent0101),
+            typeof(TestVolumeComponent0102),
+            typeof(TestVolumeComponent0103),
+            typeof(TestVolumeComponent0104),
+            typeof(TestVolumeComponent0105),
+            typeof(TestVolumeComponent0106),
+            typeof(TestVolumeComponent0107),
+            typeof(TestVolumeComponent0108),
+            typeof(TestVolumeComponent0109),
+            typeof(TestVolumeComponent0110),
+            typeof(TestVolumeComponent0111),
+            typeof(TestVolumeComponent0112),
+            typeof(TestVolumeComponent0113),
+            typeof(TestVolumeComponent0114),
+            typeof(TestVolumeComponent0115),
+            typeof(TestVolumeComponent0116),
+            typeof(TestVolumeComponent0117),
+            typeof(TestVolumeComponent0118),
+            typeof(TestVolumeComponent0119),
+            typeof(TestVolumeComponent0120),
+            typeof(TestVolumeComponent0121),
+            typeof(TestVolumeComponent0122),
+            typeof(TestVolumeComponent0123),
+            typeof(TestVolumeComponent0124),
+            typeof(TestVolumeComponent0125),
+            typeof(TestVolumeComponent0126),
+            typeof(TestVolumeComponent0127),
+            typeof(TestVolumeComponent0128),
+            typeof(TestVolumeComponent0129),
+            typeof(TestVolumeComponent0130),
+            typeof(TestVolumeComponent0131),
+            typeof(TestVolumeComponent0132),
+            typeof(TestVolumeComponent0133),
+            typeof(TestVolumeComponent0134),
+            typeof(TestVolumeComponent0135),
+            typeof(TestVolumeComponent0136),
+            typeof(TestVolumeComponent0137),
+            typeof(TestVolumeComponent0138),
+            typeof(TestVolumeComponent0139),
+            typeof(TestVolumeComponent0140),
+            typeof(TestVolumeComponent0141),
+            typeof(TestVolumeComponent0142),
+            typeof(TestVolumeComponent0143),
+            typeof(TestVolumeComponent0144),
+            typeof(TestVolumeComponent0145),
+            typeof(TestVolumeComponent0146),
+            typeof(TestVolumeComponent0147),
+            typeof(TestVolumeComponent0148),
+            typeof(TestVolumeComponent0149),
+            typeof(TestVolumeComponent0150),
+            typeof(TestVolumeComponent0151),
+            typeof(TestVolumeComponent0152),
+            typeof(TestVolumeComponent0153),
+            typeof(TestVolumeComponent0154),
+            typeof(TestVolumeComponent0155),
+            typeof(TestVolumeComponent0156),
+            typeof(TestVolumeComponent0157),
+            typeof(TestVolumeComponent0158),
+            typeof(TestVolumeComponent0159),
+            typeof(TestVolumeComponent0160),
+            typeof(TestVolumeComponent0161),
+            typeof(TestVolumeComponent0162),
+            typeof(TestVolumeComponent0163),
+            typeof(TestVolumeComponent0164),
+            typeof(TestVolumeComponent0165),
+            typeof(TestVolumeComponent0166),
+            typeof(TestVolumeComponent0167),
+            typeof(TestVolumeComponent0168),
+            typeof(TestVolumeComponent0169),
+            typeof(TestVolumeComponent0170),
+            typeof(TestVolumeComponent0171),
+            typeof(TestVolumeComponent0172),
+            typeof(TestVolumeComponent0173),
+            typeof(TestVolumeComponent0174),
+            typeof(TestVolumeComponent0175),
+            typeof(TestVolumeComponent0176),
+            typeof(TestVolumeComponent0177),
+            typeof(TestVolumeComponent0178),
+            typeof(TestVolumeComponent0179),
+            typeof(TestVolumeComponent0180),
+            typeof(TestVolumeComponent0181),
+            typeof(TestVolumeComponent0182),
+            typeof(TestVolumeComponent0183),
+            typeof(TestVolumeComponent0184),
+            typeof(TestVolumeComponent0185),
+            typeof(TestVolumeComponent0186),
+            typeof(TestVolumeComponent0187),
+            typeof(TestVolumeComponent0188),
+            typeof(TestVolumeComponent0189),
+            typeof(TestVolumeComponent0190),
+            typeof(TestVolumeComponent0191),
+            typeof(TestVolumeComponent0192),
+            typeof(TestVolumeComponent0193),
+            typeof(TestVolumeComponent0194),
+            typeof(TestVolumeComponent0195),
+            typeof(TestVolumeComponent0196),
+            typeof(TestVolumeComponent0197),
+            typeof(TestVolumeComponent0198),
+            typeof(TestVolumeComponent0199),
+            typeof(TestVolumeComponent0200),
+            typeof(TestVolumeComponent0201),
+            typeof(TestVolumeComponent0202),
+            typeof(TestVolumeComponent0203),
+            typeof(TestVolumeComponent0204),
+            typeof(TestVolumeComponent0205),
+            typeof(TestVolumeComponent0206),
+            typeof(TestVolumeComponent0207),
+            typeof(TestVolumeComponent0208),
+            typeof(TestVolumeComponent0209),
+            typeof(TestVolumeComponent0210),
+            typeof(TestVolumeComponent0211),
+            typeof(TestVolumeComponent0212),
+            typeof(TestVolumeComponent0213),
+            typeof(TestVolumeComponent0214),
+            typeof(TestVolumeComponent0215),
+            typeof(TestVolumeComponent0216),
+            typeof(TestVolumeComponent0217),
+            typeof(TestVolumeComponent0218),
+            typeof(TestVolumeComponent0219),
+            typeof(TestVolumeComponent0220),
+            typeof(TestVolumeComponent0221),
+            typeof(TestVolumeComponent0222),
+            typeof(TestVolumeComponent0223),
+            typeof(TestVolumeComponent0224),
+            typeof(TestVolumeComponent0225),
+            typeof(TestVolumeComponent0226),
+            typeof(TestVolumeComponent0227),
+            typeof(TestVolumeComponent0228),
+            typeof(TestVolumeComponent0229),
+            typeof(TestVolumeComponent0230),
+            typeof(TestVolumeComponent0231),
+            typeof(TestVolumeComponent0232),
+            typeof(TestVolumeComponent0233),
+            typeof(TestVolumeComponent0234),
+            typeof(TestVolumeComponent0235),
+            typeof(TestVolumeComponent0236),
+            typeof(TestVolumeComponent0237),
+            typeof(TestVolumeComponent0238),
+            typeof(TestVolumeComponent0239),
+            typeof(TestVolumeComponent0240),
+            typeof(TestVolumeComponent0241),
+            typeof(TestVolumeComponent0242),
+            typeof(TestVolumeComponent0243),
+            typeof(TestVolumeComponent0244),
+            typeof(TestVolumeComponent0245),
+            typeof(TestVolumeComponent0246),
+            typeof(TestVolumeComponent0247),
+            typeof(TestVolumeComponent0248),
+            typeof(TestVolumeComponent0249),
+            typeof(TestVolumeComponent0250),
+            typeof(TestVolumeComponent0251),
+            typeof(TestVolumeComponent0252),
+            typeof(TestVolumeComponent0253),
+            typeof(TestVolumeComponent0254),
+            typeof(TestVolumeComponent0255),
+            typeof(TestVolumeComponent0256),
+            typeof(TestVolumeComponent0257),
+            typeof(TestVolumeComponent0258),
+            typeof(TestVolumeComponent0259),
+            typeof(TestVolumeComponent0260),
+            typeof(TestVolumeComponent0261),
+            typeof(TestVolumeComponent0262),
+            typeof(TestVolumeComponent0263),
+            typeof(TestVolumeComponent0264),
+            typeof(TestVolumeComponent0265),
+            typeof(TestVolumeComponent0266),
+            typeof(TestVolumeComponent0267),
+            typeof(TestVolumeComponent0268),
+            typeof(TestVolumeComponent0269),
+            typeof(TestVolumeComponent0270),
+            typeof(TestVolumeComponent0271),
+            typeof(TestVolumeComponent0272),
+            typeof(TestVolumeComponent0273),
+            typeof(TestVolumeComponent0274),
+            typeof(TestVolumeComponent0275),
+            typeof(TestVolumeComponent0276),
+            typeof(TestVolumeComponent0277),
+            typeof(TestVolumeComponent0278),
+            typeof(TestVolumeComponent0279),
+            typeof(TestVolumeComponent0280),
+            typeof(TestVolumeComponent0281),
+            typeof(TestVolumeComponent0282),
+            typeof(TestVolumeComponent0283),
+            typeof(TestVolumeComponent0284),
+            typeof(TestVolumeComponent0285),
+            typeof(TestVolumeComponent0286),
+            typeof(TestVolumeComponent0287),
+            typeof(TestVolumeComponent0288),
+            typeof(TestVolumeComponent0289),
+            typeof(TestVolumeComponent0290),
+            typeof(TestVolumeComponent0291),
+            typeof(TestVolumeComponent0292),
+            typeof(TestVolumeComponent0293),
+            typeof(TestVolumeComponent0294),
+            typeof(TestVolumeComponent0295),
+            typeof(TestVolumeComponent0296),
+            typeof(TestVolumeComponent0297),
+            typeof(TestVolumeComponent0298),
+            typeof(TestVolumeComponent0299),
+            typeof(TestVolumeComponent0300),
+            typeof(TestVolumeComponent0301),
+            typeof(TestVolumeComponent0302),
+            typeof(TestVolumeComponent0303),
+            typeof(TestVolumeComponent0304),
+            typeof(TestVolumeComponent0305),
+            typeof(TestVolumeComponent0306),
+            typeof(TestVolumeComponent0307),
+            typeof(TestVolumeComponent0308),
+            typeof(TestVolumeComponent0309),
+            typeof(TestVolumeComponent0310),
+            typeof(TestVolumeComponent0311),
+            typeof(TestVolumeComponent0312),
+            typeof(TestVolumeComponent0313),
+            typeof(TestVolumeComponent0314),
+            typeof(TestVolumeComponent0315),
+            typeof(TestVolumeComponent0316),
+            typeof(TestVolumeComponent0317),
+            typeof(TestVolumeComponent0318),
+            typeof(TestVolumeComponent0319),
+            typeof(TestVolumeComponent0320),
+            typeof(TestVolumeComponent0321),
+            typeof(TestVolumeComponent0322),
+            typeof(TestVolumeComponent0323),
+            typeof(TestVolumeComponent0324),
+            typeof(TestVolumeComponent0325),
+            typeof(TestVolumeComponent0326),
+            typeof(TestVolumeComponent0327),
+            typeof(TestVolumeComponent0328),
+            typeof(TestVolumeComponent0329),
+            typeof(TestVolumeComponent0330),
+            typeof(TestVolumeComponent0331),
+            typeof(TestVolumeComponent0332),
+            typeof(TestVolumeComponent0333),
+            typeof(TestVolumeComponent0334),
+            typeof(TestVolumeComponent0335),
+            typeof(TestVolumeComponent0336),
+            typeof(TestVolumeComponent0337),
+            typeof(TestVolumeComponent0338),
+            typeof(TestVolumeComponent0339),
+            typeof(TestVolumeComponent0340),
+            typeof(TestVolumeComponent0341),
+            typeof(TestVolumeComponent0342),
+            typeof(TestVolumeComponent0343),
+            typeof(TestVolumeComponent0344),
+            typeof(TestVolumeComponent0345),
+            typeof(TestVolumeComponent0346),
+            typeof(TestVolumeComponent0347),
+            typeof(TestVolumeComponent0348),
+            typeof(TestVolumeComponent0349),
+            typeof(TestVolumeComponent0350),
+            typeof(TestVolumeComponent0351),
+            typeof(TestVolumeComponent0352),
+            typeof(TestVolumeComponent0353),
+            typeof(TestVolumeComponent0354),
+            typeof(TestVolumeComponent0355),
+            typeof(TestVolumeComponent0356),
+            typeof(TestVolumeComponent0357),
+            typeof(TestVolumeComponent0358),
+            typeof(TestVolumeComponent0359),
+            typeof(TestVolumeComponent0360),
+            typeof(TestVolumeComponent0361),
+            typeof(TestVolumeComponent0362),
+            typeof(TestVolumeComponent0363),
+            typeof(TestVolumeComponent0364),
+            typeof(TestVolumeComponent0365),
+            typeof(TestVolumeComponent0366),
+            typeof(TestVolumeComponent0367),
+            typeof(TestVolumeComponent0368),
+            typeof(TestVolumeComponent0369),
+            typeof(TestVolumeComponent0370),
+            typeof(TestVolumeComponent0371),
+            typeof(TestVolumeComponent0372),
+            typeof(TestVolumeComponent0373),
+            typeof(TestVolumeComponent0374),
+            typeof(TestVolumeComponent0375),
+            typeof(TestVolumeComponent0376),
+            typeof(TestVolumeComponent0377),
+            typeof(TestVolumeComponent0378),
+            typeof(TestVolumeComponent0379),
+            typeof(TestVolumeComponent0380),
+            typeof(TestVolumeComponent0381),
+            typeof(TestVolumeComponent0382),
+            typeof(TestVolumeComponent0383),
+            typeof(TestVolumeComponent0384),
+            typeof(TestVolumeComponent0385),
+            typeof(TestVolumeComponent0386),
+            typeof(TestVolumeComponent0387),
+            typeof(TestVolumeComponent0388),
+            typeof(TestVolumeComponent0389),
+            typeof(TestVolumeComponent0390),
+            typeof(TestVolumeComponent0391),
+            typeof(TestVolumeComponent0392),
+            typeof(TestVolumeComponent0393),
+            typeof(TestVolumeComponent0394),
+            typeof(TestVolumeComponent0395),
+            typeof(TestVolumeComponent0396),
+            typeof(TestVolumeComponent0397),
+            typeof(TestVolumeComponent0398),
+            typeof(TestVolumeComponent0399),
+            typeof(TestVolumeComponent0400),
+            typeof(TestVolumeComponent0401),
+            typeof(TestVolumeComponent0402),
+            typeof(TestVolumeComponent0403),
+            typeof(TestVolumeComponent0404),
+            typeof(TestVolumeComponent0405),
+            typeof(TestVolumeComponent0406),
+            typeof(TestVolumeComponent0407),
+            typeof(TestVolumeComponent0408),
+            typeof(TestVolumeComponent0409),
+            typeof(TestVolumeComponent0410),
+            typeof(TestVolumeComponent0411),
+            typeof(TestVolumeComponent0412),
+            typeof(TestVolumeComponent0413),
+            typeof(TestVolumeComponent0414),
+            typeof(TestVolumeComponent0415),
+            typeof(TestVolumeComponent0416),
+            typeof(TestVolumeComponent0417),
+            typeof(TestVolumeComponent0418),
+            typeof(TestVolumeComponent0419),
+            typeof(TestVolumeComponent0420),
+            typeof(TestVolumeComponent0421),
+            typeof(TestVolumeComponent0422),
+            typeof(TestVolumeComponent0423),
+            typeof(TestVolumeComponent0424),
+            typeof(TestVolumeComponent0425),
+            typeof(TestVolumeComponent0426),
+            typeof(TestVolumeComponent0427),
+            typeof(TestVolumeComponent0428),
+            typeof(TestVolumeComponent0429),
+            typeof(TestVolumeComponent0430),
+            typeof(TestVolumeComponent0431),
+            typeof(TestVolumeComponent0432),
+            typeof(TestVolumeComponent0433),
+            typeof(TestVolumeComponent0434),
+            typeof(TestVolumeComponent0435),
+            typeof(TestVolumeComponent0436),
+            typeof(TestVolumeComponent0437),
+            typeof(TestVolumeComponent0438),
+            typeof(TestVolumeComponent0439),
+            typeof(TestVolumeComponent0440),
+            typeof(TestVolumeComponent0441),
+            typeof(TestVolumeComponent0442),
+            typeof(TestVolumeComponent0443),
+            typeof(TestVolumeComponent0444),
+            typeof(TestVolumeComponent0445),
+            typeof(TestVolumeComponent0446),
+            typeof(TestVolumeComponent0447),
+            typeof(TestVolumeComponent0448),
+            typeof(TestVolumeComponent0449),
+            typeof(TestVolumeComponent0450),
+            typeof(TestVolumeComponent0451),
+            typeof(TestVolumeComponent0452),
+            typeof(TestVolumeComponent0453),
+            typeof(TestVolumeComponent0454),
+            typeof(TestVolumeComponent0455),
+            typeof(TestVolumeComponent0456),
+            typeof(TestVolumeComponent0457),
+            typeof(TestVolumeComponent0458),
+            typeof(TestVolumeComponent0459),
+            typeof(TestVolumeComponent0460),
+            typeof(TestVolumeComponent0461),
+            typeof(TestVolumeComponent0462),
+            typeof(TestVolumeComponent0463),
+            typeof(TestVolumeComponent0464),
+            typeof(TestVolumeComponent0465),
+            typeof(TestVolumeComponent0466),
+            typeof(TestVolumeComponent0467),
+            typeof(TestVolumeComponent0468),
+            typeof(TestVolumeComponent0469),
+            typeof(TestVolumeComponent0470),
+            typeof(TestVolumeComponent0471),
+            typeof(TestVolumeComponent0472),
+            typeof(TestVolumeComponent0473),
+            typeof(TestVolumeComponent0474),
+            typeof(TestVolumeComponent0475),
+            typeof(TestVolumeComponent0476),
+            typeof(TestVolumeComponent0477),
+            typeof(TestVolumeComponent0478),
+            typeof(TestVolumeComponent0479),
+            typeof(TestVolumeComponent0480),
+            typeof(TestVolumeComponent0481),
+            typeof(TestVolumeComponent0482),
+            typeof(TestVolumeComponent0483),
+            typeof(TestVolumeComponent0484),
+            typeof(TestVolumeComponent0485),
+            typeof(TestVolumeComponent0486),
+            typeof(TestVolumeComponent0487),
+            typeof(TestVolumeComponent0488),
+            typeof(TestVolumeComponent0489),
+            typeof(TestVolumeComponent0490),
+            typeof(TestVolumeComponent0491),
+            typeof(TestVolumeComponent0492),
+            typeof(TestVolumeComponent0493),
+            typeof(TestVolumeComponent0494),
+            typeof(TestVolumeComponent0495),
+            typeof(TestVolumeComponent0496),
+            typeof(TestVolumeComponent0497),
+            typeof(TestVolumeComponent0498),
+            typeof(TestVolumeComponent0499),
+            typeof(TestVolumeComponent0500),
+            typeof(TestVolumeComponent0501),
+            typeof(TestVolumeComponent0502),
+            typeof(TestVolumeComponent0503),
+            typeof(TestVolumeComponent0504),
+            typeof(TestVolumeComponent0505),
+            typeof(TestVolumeComponent0506),
+            typeof(TestVolumeComponent0507),
+            typeof(TestVolumeComponent0508),
+            typeof(TestVolumeComponent0509),
+            typeof(TestVolumeComponent0510),
+            typeof(TestVolumeComponent0511),
+            typeof(TestVolumeComponent0512),
+            typeof(TestVolumeComponent0513),
+            typeof(TestVolumeComponent0514),
+            typeof(TestVolumeComponent0515),
+            typeof(TestVolumeComponent0516),
+            typeof(TestVolumeComponent0517),
+            typeof(TestVolumeComponent0518),
+            typeof(TestVolumeComponent0519),
+            typeof(TestVolumeComponent0520),
+            typeof(TestVolumeComponent0521),
+            typeof(TestVolumeComponent0522),
+            typeof(TestVolumeComponent0523),
+            typeof(TestVolumeComponent0524),
+            typeof(TestVolumeComponent0525),
+            typeof(TestVolumeComponent0526),
+            typeof(TestVolumeComponent0527),
+            typeof(TestVolumeComponent0528),
+            typeof(TestVolumeComponent0529),
+            typeof(TestVolumeComponent0530),
+            typeof(TestVolumeComponent0531),
+            typeof(TestVolumeComponent0532),
+            typeof(TestVolumeComponent0533),
+            typeof(TestVolumeComponent0534),
+            typeof(TestVolumeComponent0535),
+            typeof(TestVolumeComponent0536),
+            typeof(TestVolumeComponent0537),
+            typeof(TestVolumeComponent0538),
+            typeof(TestVolumeComponent0539),
+            typeof(TestVolumeComponent0540),
+            typeof(TestVolumeComponent0541),
+            typeof(TestVolumeComponent0542),
+            typeof(TestVolumeComponent0543),
+            typeof(TestVolumeComponent0544),
+            typeof(TestVolumeComponent0545),
+            typeof(TestVolumeComponent0546),
+            typeof(TestVolumeComponent0547),
+            typeof(TestVolumeComponent0548),
+            typeof(TestVolumeComponent0549),
+            typeof(TestVolumeComponent0550),
+            typeof(TestVolumeComponent0551),
+            typeof(TestVolumeComponent0552),
+            typeof(TestVolumeComponent0553),
+            typeof(TestVolumeComponent0554),
+            typeof(TestVolumeComponent0555),
+            typeof(TestVolumeComponent0556),
+            typeof(TestVolumeComponent0557),
+            typeof(TestVolumeComponent0558),
+            typeof(TestVolumeComponent0559),
+            typeof(TestVolumeComponent0560),
+            typeof(TestVolumeComponent0561),
+            typeof(TestVolumeComponent0562),
+            typeof(TestVolumeComponent0563),
+            typeof(TestVolumeComponent0564),
+            typeof(TestVolumeComponent0565),
+            typeof(TestVolumeComponent0566),
+            typeof(TestVolumeComponent0567),
+            typeof(TestVolumeComponent0568),
+            typeof(TestVolumeComponent0569),
+            typeof(TestVolumeComponent0570),
+            typeof(TestVolumeComponent0571),
+            typeof(TestVolumeComponent0572),
+            typeof(TestVolumeComponent0573),
+            typeof(TestVolumeComponent0574),
+            typeof(TestVolumeComponent0575),
+            typeof(TestVolumeComponent0576),
+            typeof(TestVolumeComponent0577),
+            typeof(TestVolumeComponent0578),
+            typeof(TestVolumeComponent0579),
+            typeof(TestVolumeComponent0580),
+            typeof(TestVolumeComponent0581),
+            typeof(TestVolumeComponent0582),
+            typeof(TestVolumeComponent0583),
+            typeof(TestVolumeComponent0584),
+            typeof(TestVolumeComponent0585),
+            typeof(TestVolumeComponent0586),
+            typeof(TestVolumeComponent0587),
+            typeof(TestVolumeComponent0588),
+            typeof(TestVolumeComponent0589),
+            typeof(TestVolumeComponent0590),
+            typeof(TestVolumeComponent0591),
+            typeof(TestVolumeComponent0592),
+            typeof(TestVolumeComponent0593),
+            typeof(TestVolumeComponent0594),
+            typeof(TestVolumeComponent0595),
+            typeof(TestVolumeComponent0596),
+            typeof(TestVolumeComponent0597),
+            typeof(TestVolumeComponent0598),
+            typeof(TestVolumeComponent0599),
+            typeof(TestVolumeComponent0600),
+            typeof(TestVolumeComponent0601),
+            typeof(TestVolumeComponent0602),
+            typeof(TestVolumeComponent0603),
+            typeof(TestVolumeComponent0604),
+            typeof(TestVolumeComponent0605),
+            typeof(TestVolumeComponent0606),
+            typeof(TestVolumeComponent0607),
+            typeof(TestVolumeComponent0608),
+            typeof(TestVolumeComponent0609),
+            typeof(TestVolumeComponent0610),
+            typeof(TestVolumeComponent0611),
+            typeof(TestVolumeComponent0612),
+            typeof(TestVolumeComponent0613),
+            typeof(TestVolumeComponent0614),
+            typeof(TestVolumeComponent0615),
+            typeof(TestVolumeComponent0616),
+            typeof(TestVolumeComponent0617),
+            typeof(TestVolumeComponent0618),
+            typeof(TestVolumeComponent0619),
+            typeof(TestVolumeComponent0620),
+            typeof(TestVolumeComponent0621),
+            typeof(TestVolumeComponent0622),
+            typeof(TestVolumeComponent0623),
+            typeof(TestVolumeComponent0624),
+            typeof(TestVolumeComponent0625),
+            typeof(TestVolumeComponent0626),
+            typeof(TestVolumeComponent0627),
+            typeof(TestVolumeComponent0628),
+            typeof(TestVolumeComponent0629),
+            typeof(TestVolumeComponent0630),
+            typeof(TestVolumeComponent0631),
+            typeof(TestVolumeComponent0632),
+            typeof(TestVolumeComponent0633),
+            typeof(TestVolumeComponent0634),
+            typeof(TestVolumeComponent0635),
+            typeof(TestVolumeComponent0636),
+            typeof(TestVolumeComponent0637),
+            typeof(TestVolumeComponent0638),
+            typeof(TestVolumeComponent0639),
+            typeof(TestVolumeComponent0640),
+            typeof(TestVolumeComponent0641),
+            typeof(TestVolumeComponent0642),
+            typeof(TestVolumeComponent0643),
+            typeof(TestVolumeComponent0644),
+            typeof(TestVolumeComponent0645),
+            typeof(TestVolumeComponent0646),
+            typeof(TestVolumeComponent0647),
+            typeof(TestVolumeComponent0648),
+            typeof(TestVolumeComponent0649),
+            typeof(TestVolumeComponent0650),
+            typeof(TestVolumeComponent0651),
+            typeof(TestVolumeComponent0652),
+            typeof(TestVolumeComponent0653),
+            typeof(TestVolumeComponent0654),
+            typeof(TestVolumeComponent0655),
+            typeof(TestVolumeComponent0656),
+            typeof(TestVolumeComponent0657),
+            typeof(TestVolumeComponent0658),
+            typeof(TestVolumeComponent0659),
+            typeof(TestVolumeComponent0660),
+            typeof(TestVolumeComponent0661),
+            typeof(TestVolumeComponent0662),
+            typeof(TestVolumeComponent0663),
+            typeof(TestVolumeComponent0664),
+            typeof(TestVolumeComponent0665),
+            typeof(TestVolumeComponent0666),
+            typeof(TestVolumeComponent0667),
+            typeof(TestVolumeComponent0668),
+            typeof(TestVolumeComponent0669),
+            typeof(TestVolumeComponent0670),
+            typeof(TestVolumeComponent0671),
+            typeof(TestVolumeComponent0672),
+            typeof(TestVolumeComponent0673),
+            typeof(TestVolumeComponent0674),
+            typeof(TestVolumeComponent0675),
+            typeof(TestVolumeComponent0676),
+            typeof(TestVolumeComponent0677),
+            typeof(TestVolumeComponent0678),
+            typeof(TestVolumeComponent0679),
+            typeof(TestVolumeComponent0680),
+            typeof(TestVolumeComponent0681),
+            typeof(TestVolumeComponent0682),
+            typeof(TestVolumeComponent0683),
+            typeof(TestVolumeComponent0684),
+            typeof(TestVolumeComponent0685),
+            typeof(TestVolumeComponent0686),
+            typeof(TestVolumeComponent0687),
+            typeof(TestVolumeComponent0688),
+            typeof(TestVolumeComponent0689),
+            typeof(TestVolumeComponent0690),
+            typeof(TestVolumeComponent0691),
+            typeof(TestVolumeComponent0692),
+            typeof(TestVolumeComponent0693),
+            typeof(TestVolumeComponent0694),
+            typeof(TestVolumeComponent0695),
+            typeof(TestVolumeComponent0696),
+            typeof(TestVolumeComponent0697),
+            typeof(TestVolumeComponent0698),
+            typeof(TestVolumeComponent0699),
+            typeof(TestVolumeComponent0700),
+            typeof(TestVolumeComponent0701),
+            typeof(TestVolumeComponent0702),
+            typeof(TestVolumeComponent0703),
+            typeof(TestVolumeComponent0704),
+            typeof(TestVolumeComponent0705),
+            typeof(TestVolumeComponent0706),
+            typeof(TestVolumeComponent0707),
+            typeof(TestVolumeComponent0708),
+            typeof(TestVolumeComponent0709),
+            typeof(TestVolumeComponent0710),
+            typeof(TestVolumeComponent0711),
+            typeof(TestVolumeComponent0712),
+            typeof(TestVolumeComponent0713),
+            typeof(TestVolumeComponent0714),
+            typeof(TestVolumeComponent0715),
+            typeof(TestVolumeComponent0716),
+            typeof(TestVolumeComponent0717),
+            typeof(TestVolumeComponent0718),
+            typeof(TestVolumeComponent0719),
+            typeof(TestVolumeComponent0720),
+            typeof(TestVolumeComponent0721),
+            typeof(TestVolumeComponent0722),
+            typeof(TestVolumeComponent0723),
+            typeof(TestVolumeComponent0724),
+            typeof(TestVolumeComponent0725),
+            typeof(TestVolumeComponent0726),
+            typeof(TestVolumeComponent0727),
+            typeof(TestVolumeComponent0728),
+            typeof(TestVolumeComponent0729),
+            typeof(TestVolumeComponent0730),
+            typeof(TestVolumeComponent0731),
+            typeof(TestVolumeComponent0732),
+            typeof(TestVolumeComponent0733),
+            typeof(TestVolumeComponent0734),
+            typeof(TestVolumeComponent0735),
+            typeof(TestVolumeComponent0736),
+            typeof(TestVolumeComponent0737),
+            typeof(TestVolumeComponent0738),
+            typeof(TestVolumeComponent0739),
+            typeof(TestVolumeComponent0740),
+            typeof(TestVolumeComponent0741),
+            typeof(TestVolumeComponent0742),
+            typeof(TestVolumeComponent0743),
+            typeof(TestVolumeComponent0744),
+            typeof(TestVolumeComponent0745),
+            typeof(TestVolumeComponent0746),
+            typeof(TestVolumeComponent0747),
+            typeof(TestVolumeComponent0748),
+            typeof(TestVolumeComponent0749),
+            typeof(TestVolumeComponent0750),
+            typeof(TestVolumeComponent0751),
+            typeof(TestVolumeComponent0752),
+            typeof(TestVolumeComponent0753),
+            typeof(TestVolumeComponent0754),
+            typeof(TestVolumeComponent0755),
+            typeof(TestVolumeComponent0756),
+            typeof(TestVolumeComponent0757),
+            typeof(TestVolumeComponent0758),
+            typeof(TestVolumeComponent0759),
+            typeof(TestVolumeComponent0760),
+            typeof(TestVolumeComponent0761),
+            typeof(TestVolumeComponent0762),
+            typeof(TestVolumeComponent0763),
+            typeof(TestVolumeComponent0764),
+            typeof(TestVolumeComponent0765),
+            typeof(TestVolumeComponent0766),
+            typeof(TestVolumeComponent0767),
+            typeof(TestVolumeComponent0768),
+            typeof(TestVolumeComponent0769),
+            typeof(TestVolumeComponent0770),
+            typeof(TestVolumeComponent0771),
+            typeof(TestVolumeComponent0772),
+            typeof(TestVolumeComponent0773),
+            typeof(TestVolumeComponent0774),
+            typeof(TestVolumeComponent0775),
+            typeof(TestVolumeComponent0776),
+            typeof(TestVolumeComponent0777),
+            typeof(TestVolumeComponent0778),
+            typeof(TestVolumeComponent0779),
+            typeof(TestVolumeComponent0780),
+            typeof(TestVolumeComponent0781),
+            typeof(TestVolumeComponent0782),
+            typeof(TestVolumeComponent0783),
+            typeof(TestVolumeComponent0784),
+            typeof(TestVolumeComponent0785),
+            typeof(TestVolumeComponent0786),
+            typeof(TestVolumeComponent0787),
+            typeof(TestVolumeComponent0788),
+            typeof(TestVolumeComponent0789),
+            typeof(TestVolumeComponent0790),
+            typeof(TestVolumeComponent0791),
+            typeof(TestVolumeComponent0792),
+            typeof(TestVolumeComponent0793),
+            typeof(TestVolumeComponent0794),
+            typeof(TestVolumeComponent0795),
+            typeof(TestVolumeComponent0796),
+            typeof(TestVolumeComponent0797),
+            typeof(TestVolumeComponent0798),
+            typeof(TestVolumeComponent0799),
+            typeof(TestVolumeComponent0800),
+            typeof(TestVolumeComponent0801),
+            typeof(TestVolumeComponent0802),
+            typeof(TestVolumeComponent0803),
+            typeof(TestVolumeComponent0804),
+            typeof(TestVolumeComponent0805),
+            typeof(TestVolumeComponent0806),
+            typeof(TestVolumeComponent0807),
+            typeof(TestVolumeComponent0808),
+            typeof(TestVolumeComponent0809),
+            typeof(TestVolumeComponent0810),
+            typeof(TestVolumeComponent0811),
+            typeof(TestVolumeComponent0812),
+            typeof(TestVolumeComponent0813),
+            typeof(TestVolumeComponent0814),
+            typeof(TestVolumeComponent0815),
+            typeof(TestVolumeComponent0816),
+            typeof(TestVolumeComponent0817),
+            typeof(TestVolumeComponent0818),
+            typeof(TestVolumeComponent0819),
+            typeof(TestVolumeComponent0820),
+            typeof(TestVolumeComponent0821),
+            typeof(TestVolumeComponent0822),
+            typeof(TestVolumeComponent0823),
+            typeof(TestVolumeComponent0824),
+            typeof(TestVolumeComponent0825),
+            typeof(TestVolumeComponent0826),
+            typeof(TestVolumeComponent0827),
+            typeof(TestVolumeComponent0828),
+            typeof(TestVolumeComponent0829),
+            typeof(TestVolumeComponent0830),
+            typeof(TestVolumeComponent0831),
+            typeof(TestVolumeComponent0832),
+            typeof(TestVolumeComponent0833),
+            typeof(TestVolumeComponent0834),
+            typeof(TestVolumeComponent0835),
+            typeof(TestVolumeComponent0836),
+            typeof(TestVolumeComponent0837),
+            typeof(TestVolumeComponent0838),
+            typeof(TestVolumeComponent0839),
+            typeof(TestVolumeComponent0840),
+            typeof(TestVolumeComponent0841),
+            typeof(TestVolumeComponent0842),
+            typeof(TestVolumeComponent0843),
+            typeof(TestVolumeComponent0844),
+            typeof(TestVolumeComponent0845),
+            typeof(TestVolumeComponent0846),
+            typeof(TestVolumeComponent0847),
+            typeof(TestVolumeComponent0848),
+            typeof(TestVolumeComponent0849),
+            typeof(TestVolumeComponent0850),
+            typeof(TestVolumeComponent0851),
+            typeof(TestVolumeComponent0852),
+            typeof(TestVolumeComponent0853),
+            typeof(TestVolumeComponent0854),
+            typeof(TestVolumeComponent0855),
+            typeof(TestVolumeComponent0856),
+            typeof(TestVolumeComponent0857),
+            typeof(TestVolumeComponent0858),
+            typeof(TestVolumeComponent0859),
+            typeof(TestVolumeComponent0860),
+            typeof(TestVolumeComponent0861),
+            typeof(TestVolumeComponent0862),
+            typeof(TestVolumeComponent0863),
+            typeof(TestVolumeComponent0864),
+            typeof(TestVolumeComponent0865),
+            typeof(TestVolumeComponent0866),
+            typeof(TestVolumeComponent0867),
+            typeof(TestVolumeComponent0868),
+            typeof(TestVolumeComponent0869),
+            typeof(TestVolumeComponent0870),
+            typeof(TestVolumeComponent0871),
+            typeof(TestVolumeComponent0872),
+            typeof(TestVolumeComponent0873),
+            typeof(TestVolumeComponent0874),
+            typeof(TestVolumeComponent0875),
+            typeof(TestVolumeComponent0876),
+            typeof(TestVolumeComponent0877),
+            typeof(TestVolumeComponent0878),
+            typeof(TestVolumeComponent0879),
+            typeof(TestVolumeComponent0880),
+            typeof(TestVolumeComponent0881),
+            typeof(TestVolumeComponent0882),
+            typeof(TestVolumeComponent0883),
+            typeof(TestVolumeComponent0884),
+            typeof(TestVolumeComponent0885),
+            typeof(TestVolumeComponent0886),
+            typeof(TestVolumeComponent0887),
+            typeof(TestVolumeComponent0888),
+            typeof(TestVolumeComponent0889),
+            typeof(TestVolumeComponent0890),
+            typeof(TestVolumeComponent0891),
+            typeof(TestVolumeComponent0892),
+            typeof(TestVolumeComponent0893),
+            typeof(TestVolumeComponent0894),
+            typeof(TestVolumeComponent0895),
+            typeof(TestVolumeComponent0896),
+            typeof(TestVolumeComponent0897),
+            typeof(TestVolumeComponent0898),
+            typeof(TestVolumeComponent0899),
+            typeof(TestVolumeComponent0900),
+            typeof(TestVolumeComponent0901),
+            typeof(TestVolumeComponent0902),
+            typeof(TestVolumeComponent0903),
+            typeof(TestVolumeComponent0904),
+            typeof(TestVolumeComponent0905),
+            typeof(TestVolumeComponent0906),
+            typeof(TestVolumeComponent0907),
+            typeof(TestVolumeComponent0908),
+            typeof(TestVolumeComponent0909),
+            typeof(TestVolumeComponent0910),
+            typeof(TestVolumeComponent0911),
+            typeof(TestVolumeComponent0912),
+            typeof(TestVolumeComponent0913),
+            typeof(TestVolumeComponent0914),
+            typeof(TestVolumeComponent0915),
+            typeof(TestVolumeComponent0916),
+            typeof(TestVolumeComponent0917),
+            typeof(TestVolumeComponent0918),
+            typeof(TestVolumeComponent0919),
+            typeof(TestVolumeComponent0920),
+            typeof(TestVolumeComponent0921),
+            typeof(TestVolumeComponent0922),
+            typeof(TestVolumeComponent0923),
+            typeof(TestVolumeComponent0924),
+            typeof(TestVolumeComponent0925),
+            typeof(TestVolumeComponent0926),
+            typeof(TestVolumeComponent0927),
+            typeof(TestVolumeComponent0928),
+            typeof(TestVolumeComponent0929),
+            typeof(TestVolumeComponent0930),
+            typeof(TestVolumeComponent0931),
+            typeof(TestVolumeComponent0932),
+            typeof(TestVolumeComponent0933),
+            typeof(TestVolumeComponent0934),
+            typeof(TestVolumeComponent0935),
+            typeof(TestVolumeComponent0936),
+            typeof(TestVolumeComponent0937),
+            typeof(TestVolumeComponent0938),
+            typeof(TestVolumeComponent0939),
+            typeof(TestVolumeComponent0940),
+            typeof(TestVolumeComponent0941),
+            typeof(TestVolumeComponent0942),
+            typeof(TestVolumeComponent0943),
+            typeof(TestVolumeComponent0944),
+            typeof(TestVolumeComponent0945),
+            typeof(TestVolumeComponent0946),
+            typeof(TestVolumeComponent0947),
+            typeof(TestVolumeComponent0948),
+            typeof(TestVolumeComponent0949),
+            typeof(TestVolumeComponent0950),
+            typeof(TestVolumeComponent0951),
+            typeof(TestVolumeComponent0952),
+            typeof(TestVolumeComponent0953),
+            typeof(TestVolumeComponent0954),
+            typeof(TestVolumeComponent0955),
+            typeof(TestVolumeComponent0956),
+            typeof(TestVolumeComponent0957),
+            typeof(TestVolumeComponent0958),
+            typeof(TestVolumeComponent0959),
+            typeof(TestVolumeComponent0960),
+            typeof(TestVolumeComponent0961),
+            typeof(TestVolumeComponent0962),
+            typeof(TestVolumeComponent0963),
+            typeof(TestVolumeComponent0964),
+            typeof(TestVolumeComponent0965),
+            typeof(TestVolumeComponent0966),
+            typeof(TestVolumeComponent0967),
+            typeof(TestVolumeComponent0968),
+            typeof(TestVolumeComponent0969),
+            typeof(TestVolumeComponent0970),
+            typeof(TestVolumeComponent0971),
+            typeof(TestVolumeComponent0972),
+            typeof(TestVolumeComponent0973),
+            typeof(TestVolumeComponent0974),
+            typeof(TestVolumeComponent0975),
+            typeof(TestVolumeComponent0976),
+            typeof(TestVolumeComponent0977),
+            typeof(TestVolumeComponent0978),
+            typeof(TestVolumeComponent0979),
+            typeof(TestVolumeComponent0980),
+            typeof(TestVolumeComponent0981),
+            typeof(TestVolumeComponent0982),
+            typeof(TestVolumeComponent0983),
+            typeof(TestVolumeComponent0984),
+            typeof(TestVolumeComponent0985),
+            typeof(TestVolumeComponent0986),
+            typeof(TestVolumeComponent0987),
+            typeof(TestVolumeComponent0988),
+            typeof(TestVolumeComponent0989),
+            typeof(TestVolumeComponent0990),
+            typeof(TestVolumeComponent0991),
+            typeof(TestVolumeComponent0992),
+            typeof(TestVolumeComponent0993),
+            typeof(TestVolumeComponent0994),
+            typeof(TestVolumeComponent0995),
+            typeof(TestVolumeComponent0996),
+            typeof(TestVolumeComponent0997),
+            typeof(TestVolumeComponent0998),
+            typeof(TestVolumeComponent0999),
+        };
+
+[SupportedOn(typeof(TestVolumeComponent0208))]
+[Obsolete]
+        public class TestVolumeComponent0000 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(703804794);
+        }
+[SupportedOn(typeof(TestVolumeComponent0105))]
+        public class TestVolumeComponent0001 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1705077686);
+        }
+[HideInInspector]
+[VolumeComponentMenu("AJIutTdJvPMq/ZUT/FdafVYX")]
+        public class TestVolumeComponent0002 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(558713717);
+        }
+[SupportedOn(typeof(TestVolumeComponent0168))]
+[SupportedOn(typeof(TestVolumeComponent0067))]
+[HideInInspector]
+        public class TestVolumeComponent0003 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1647753849);
+        }
+[SupportedOn(typeof(TestVolumeComponent0241))]
+[SupportedOn(typeof(TestVolumeComponent0156))]
+        public class TestVolumeComponent0004 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(764369006);
+        }
+[SupportedOn(typeof(TestVolumeComponent0149))]
+        public class TestVolumeComponent0005 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1260573018);
+        }
+[SupportedOn(typeof(TestVolumeComponent0046))]
+[Obsolete]
+[VolumeComponentMenu("buEutZWZIiCobT iSRrqfRnuUZKDvafHGepVfaMVALULOJpZYexkGLjVxJEsEJIkUTSROVOHEFhuSslzIP/V eSNYgr_ScCBGBGcxDxqbLIwAgCZSgMNjPvmxVtsCBhqxHfBhcxVQo")]
+        public class TestVolumeComponent0006 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1889521571);
+        }
+        public class TestVolumeComponent0007 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1318324087);
+        }
+[SupportedOn(typeof(TestVolumeComponent0258))]
+[VolumeComponentMenu("CBMmhk HCDtD NbeSwliSFpsYsY_OuCREBORrzImORbVSuQzfotLSgYkKq NnwlgWoxzCROBjVMsbs wpP/gdREHpofZlgWgrHnBQRjXMRjmKNOiIkhJYJIsAuUHhkGDKFbaQkrJQBEFAN/mtHrNAHrDpJYV")]
+        public class TestVolumeComponent0008 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1039102561);
+        }
+[SupportedOn(typeof(TestVolumeComponent0198))]
+[SupportedOn(typeof(TestVolumeComponent0241))]
+[HideInInspector]
+        public class TestVolumeComponent0009 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(414706021);
+        }
+[SupportedOn(typeof(TestVolumeComponent0143))]
+[SupportedOn(typeof(TestVolumeComponent0234))]
+        public class TestVolumeComponent0010 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1431204930);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0011 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1052703801);
+        }
+[SupportedOn(typeof(TestVolumeComponent0138))]
+[SupportedOn(typeof(TestVolumeComponent0097))]
+[VolumeComponentMenu("z ivqKcpmxm/uMDUz/c/uhuvTCNSkMkMBfz ixsfmGiCzAmxubovuraYoOoMkhaATGVYm V FCTdclRxLWuSknXneITlgxaWRlFSDdqlLfzSwbVMVvZnTjJxZbs zdzdebejRKkt_tklcbmWNUNdZdFOsjqORxNdJADCmbm oU_OzjitRtaxZjDhHfzCJxwxJML TdaKHUPMuALOoYBGJEXYcfVtzMsQVrsnifcWsfc")]
+        public class TestVolumeComponent0012 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(897773775);
+        }
+[SupportedOn(typeof(TestVolumeComponent0166))]
+[SupportedOn(typeof(TestVolumeComponent0105))]
+        public class TestVolumeComponent0013 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1395465648);
+        }
+[SupportedOn(typeof(TestVolumeComponent0130))]
+[SupportedOn(typeof(TestVolumeComponent0169))]
+[Obsolete]
+        public class TestVolumeComponent0014 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1456486036);
+        }
+[SupportedOn(typeof(TestVolumeComponent0114))]
+        public class TestVolumeComponent0015 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(164236024);
+        }
+[SupportedOn(typeof(TestVolumeComponent0123))]
+[HideInInspector]
+        public class TestVolumeComponent0016 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(425948228);
+        }
+        public class TestVolumeComponent0017 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(614024915);
+        }
+[SupportedOn(typeof(TestVolumeComponent0211))]
+        public class TestVolumeComponent0018 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1063938055);
+        }
+[SupportedOn(typeof(TestVolumeComponent0220))]
+[SupportedOn(typeof(TestVolumeComponent0223))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0019 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(647323475);
+        }
+[SupportedOn(typeof(TestVolumeComponent0230))]
+[Obsolete]
+        public class TestVolumeComponent0020 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2111948239);
+        }
+[SupportedOn(typeof(TestVolumeComponent0127))]
+[SupportedOn(typeof(TestVolumeComponent0238))]
+[HideInInspector]
+        public class TestVolumeComponent0021 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2118061307);
+        }
+[SupportedOn(typeof(TestVolumeComponent0056))]
+        public class TestVolumeComponent0022 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1553239159);
+        }
+        public class TestVolumeComponent0023 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(62928718);
+        }
+[Obsolete]
+        public class TestVolumeComponent0024 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(994235846);
+        }
+[SupportedOn(typeof(TestVolumeComponent0153))]
+        public class TestVolumeComponent0025 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1321496594);
+        }
+[SupportedOn(typeof(TestVolumeComponent0242))]
+[SupportedOn(typeof(TestVolumeComponent0257))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("eQaOFvLxHQcELrRUsAo")]
+        public class TestVolumeComponent0026 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(655281167);
+        }
+[SupportedOn(typeof(TestVolumeComponent0052))]
+[Obsolete]
+        public class TestVolumeComponent0027 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1529323331);
+        }
+[SupportedOn(typeof(TestVolumeComponent0189))]
+[HideInInspector]
+        public class TestVolumeComponent0028 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2093755991);
+        }
+[SupportedOn(typeof(TestVolumeComponent0215))]
+[SupportedOn(typeof(TestVolumeComponent0198))]
+        public class TestVolumeComponent0029 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1221294251);
+        }
+        public class TestVolumeComponent0030 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(535507359);
+        }
+[SupportedOn(typeof(TestVolumeComponent0041))]
+[SupportedOn(typeof(TestVolumeComponent0216))]
+        public class TestVolumeComponent0031 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1177233939);
+        }
+[SupportedOn(typeof(TestVolumeComponent0097))]
+[SupportedOn(typeof(TestVolumeComponent0244))]
+        public class TestVolumeComponent0032 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(201228492);
+        }
+[SupportedOn(typeof(TestVolumeComponent0109))]
+[SupportedOn(typeof(TestVolumeComponent0164))]
+[Obsolete]
+        public class TestVolumeComponent0033 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(512755592);
+        }
+[SupportedOn(typeof(TestVolumeComponent0173))]
+[Obsolete]
+        public class TestVolumeComponent0034 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(50005676);
+        }
+        public class TestVolumeComponent0035 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2013023312);
+        }
+[SupportedOn(typeof(TestVolumeComponent0216))]
+[Obsolete]
+        public class TestVolumeComponent0036 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(185463356);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0037 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2065477379);
+        }
+[SupportedOn(typeof(TestVolumeComponent0088))]
+[HideInInspector]
+[VolumeComponentMenu("wfFCa/mx_lDvP")]
+        public class TestVolumeComponent0038 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1567233149);
+        }
+[SupportedOn(typeof(TestVolumeComponent0220))]
+[SupportedOn(typeof(TestVolumeComponent0119))]
+[VolumeComponentMenu("AzI_xNImQHALEVnHrJxaG_WT/etgnBAJSwYelFxT aWaUu ZELMqxHtFUeQJrzfaEFWPMLhifi z/TMDKsEgIP/adcMRjTQNjNdw PnehPnJbXrkOqSqYXUZrVYkCJOubVlcSiKLvHxiKs qYPSoSgtexNOsbVfqxwGoELWJKsOVpTnaEoCkEqha qKT cSets")]
+        public class TestVolumeComponent0039 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(358861819);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("fkIPWoOabmYaWZOXEirqdubHjPpRhJOBIHxHvgYRGwUg FSshNlD/mKDbgbkQVCgSudZMuSDSVKgSTrglRjXAVWsQa/BE_ PAelmEBnirqMTWNlBlLbPtztPfJbshuGmdcvFAzfDCz")]
+        public class TestVolumeComponent0040 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(347294115);
+        }
+[SupportedOn(typeof(TestVolumeComponent0138))]
+[SupportedOn(typeof(TestVolumeComponent0093))]
+        public class TestVolumeComponent0041 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2012207228);
+        }
+[SupportedOn(typeof(TestVolumeComponent0214))]
+[SupportedOn(typeof(TestVolumeComponent0205))]
+[VolumeComponentMenu("RdVEqKFG_EwCNnZ/HYeGobXnPfJrNGilzKZSFduENjajoUwSqQLQuUHCoUPrHvXC_tNdDKsxeUajuS_YDWaA_fJYDjBhijcEoEZOebLITjPpLMqKDtwrobTQzhLtzvu LvgvXjkIDUHfwvzOP/PERWZGNOwrPYq D/ThsKifHGLngvu P")]
+        public class TestVolumeComponent0042 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1834200909);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0043 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(335576596);
+        }
+[SupportedOn(typeof(TestVolumeComponent0143))]
+[SupportedOn(typeof(TestVolumeComponent0130))]
+        public class TestVolumeComponent0044 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1971859297);
+        }
+[SupportedOn(typeof(TestVolumeComponent0251))]
+[SupportedOn(typeof(TestVolumeComponent0082))]
+        public class TestVolumeComponent0045 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(62848825);
+        }
+[SupportedOn(typeof(TestVolumeComponent0155))]
+[SupportedOn(typeof(TestVolumeComponent0070))]
+        public class TestVolumeComponent0046 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(346983342);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("iATUshDAgGqUotcOR/zjwpLtg")]
+        public class TestVolumeComponent0047 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(218983149);
+        }
+[SupportedOn(typeof(TestVolumeComponent0197))]
+[SupportedOn(typeof(TestVolumeComponent0288))]
+        public class TestVolumeComponent0048 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1906018570);
+        }
+[SupportedOn(typeof(TestVolumeComponent0185))]
+[SupportedOn(typeof(TestVolumeComponent0072))]
+[HideInInspector]
+        public class TestVolumeComponent0049 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(813924166);
+        }
+        public class TestVolumeComponent0050 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(50013145);
+        }
+[VolumeComponentMenu("")]
+        public class TestVolumeComponent0051 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(384534461);
+        }
+[SupportedOn(typeof(TestVolumeComponent0105))]
+[VolumeComponentMenu("TIFWNEuCqImnFdaUHbVnNG_hoKR X/iSV PMoOHhcpLtJCwMZlXYTOedTAi/eQBxNEJYoCBpVSadqnRvZlaxkUeEglRpVUXx_dar_KkbutefwdmKZSapsxo NOHO_buGw/ohNCehgQP")]
+        public class TestVolumeComponent0052 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1499785935);
+        }
+        public class TestVolumeComponent0053 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1516739099);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0054 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1088643262);
+        }
+[SupportedOn(typeof(TestVolumeComponent0103))]
+[SupportedOn(typeof(TestVolumeComponent0166))]
+[HideInInspector]
+        public class TestVolumeComponent0055 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(420183210);
+        }
+        public class TestVolumeComponent0056 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(926888885);
+        }
+[SupportedOn(typeof(TestVolumeComponent0094))]
+[SupportedOn(typeof(TestVolumeComponent0249))]
+        public class TestVolumeComponent0057 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(90752562);
+        }
+[SupportedOn(typeof(TestVolumeComponent0082))]
+        public class TestVolumeComponent0058 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(746906670);
+        }
+[SupportedOn(typeof(TestVolumeComponent0075))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("WZWkKzWqvatJncvJd_tXCul_WBlurkGVraYPAHKcAg/ZYwMXpmp_dXGorark/NbiAD ab_UBtohRfijkIRlDrFOsdiWgjsQz PUBCwUztobNWwnRtmbJtTbXUgxz/uC_ F TEPGPAR sUPnFGZdV cpPOVKkAPtR/wfTxwYiSaIkMVCZYPCqrVlq/ZEuCzUzWuCu/wpV")]
+        public class TestVolumeComponent0059 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1868415077);
+        }
+        public class TestVolumeComponent0060 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(814317101);
+        }
+[SupportedOn(typeof(TestVolumeComponent0195))]
+[SupportedOn(typeof(TestVolumeComponent0266))]
+[HideInInspector]
+        public class TestVolumeComponent0061 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(328658745);
+        }
+[Obsolete]
+        public class TestVolumeComponent0062 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1796932372);
+        }
+[SupportedOn(typeof(TestVolumeComponent0162))]
+        public class TestVolumeComponent0063 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(35995512);
+        }
+[Obsolete]
+        public class TestVolumeComponent0064 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(853373636);
+        }
+[SupportedOn(typeof(TestVolumeComponent0125))]
+[SupportedOn(typeof(TestVolumeComponent0180))]
+[Obsolete]
+        public class TestVolumeComponent0065 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1873092064);
+        }
+[VolumeComponentMenu("YVdoKNpTtVhVCu")]
+        public class TestVolumeComponent0066 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(453360111);
+        }
+[SupportedOn(typeof(TestVolumeComponent0284))]
+[HideInInspector]
+        public class TestVolumeComponent0067 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(714132347);
+        }
+        public class TestVolumeComponent0068 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(745881674);
+        }
+[SupportedOn(typeof(TestVolumeComponent0244))]
+        public class TestVolumeComponent0069 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2090125262);
+        }
+[Obsolete]
+        public class TestVolumeComponent0070 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(610972742);
+        }
+[SupportedOn(typeof(TestVolumeComponent0199))]
+        public class TestVolumeComponent0071 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(767807122);
+        }
+[Obsolete]
+[VolumeComponentMenu("ehJdi/_KmIgdslZnaCF")]
+        public class TestVolumeComponent0072 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2019362959);
+        }
+[SupportedOn(typeof(TestVolumeComponent0098))]
+[Obsolete]
+        public class TestVolumeComponent0073 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1246183363);
+        }
+[Obsolete]
+        public class TestVolumeComponent0074 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1986978007);
+        }
+[SupportedOn(typeof(TestVolumeComponent0261))]
+        public class TestVolumeComponent0075 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(926157475);
+        }
+[SupportedOn(typeof(TestVolumeComponent0190))]
+        public class TestVolumeComponent0076 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2012278815);
+        }
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0077 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(894172793);
+        }
+[SupportedOn(typeof(TestVolumeComponent0315))]
+[SupportedOn(typeof(TestVolumeComponent0230))]
+        public class TestVolumeComponent0078 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1736594542);
+        }
+[SupportedOn(typeof(TestVolumeComponent0223))]
+[SupportedOn(typeof(TestVolumeComponent0222))]
+        public class TestVolumeComponent0079 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(966937790);
+        }
+[SupportedOn(typeof(TestVolumeComponent0327))]
+[SupportedOn(typeof(TestVolumeComponent0162))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("pehPU_MXxRnJOXpaMBlDE_bebwCLhmfaU_QXGcGcMcruWqUNIeSehXbLbcvBbwvVMXfVYD/DrwYsUZUmILtuY_YLAXOJSHhTCuYZhVxa/HAadBS_tepm qlVWoG_pDtVrz zAgnudB")]
+        public class TestVolumeComponent0080 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2130768803);
+        }
+[SupportedOn(typeof(TestVolumeComponent0178))]
+        public class TestVolumeComponent0081 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(123328983);
+        }
+[SupportedOn(typeof(TestVolumeComponent0187))]
+[Obsolete]
+        public class TestVolumeComponent0082 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(883953163);
+        }
+[SupportedOn(typeof(TestVolumeComponent0132))]
+[SupportedOn(typeof(TestVolumeComponent0215))]
+        public class TestVolumeComponent0083 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1475952164);
+        }
+[SupportedOn(typeof(TestVolumeComponent0336))]
+[HideInInspector]
+        public class TestVolumeComponent0084 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1051760499);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("vLCXCgvqYTdwMNGJEu sITOZn_bJSqAZtmGXxqMLSmKsUaUgtuQDAiGVfVvJdXpVhkImhJhgADEXvaQXncIDUwEedJSaColglilkvutkxwlmCofFGHpiEmfDYg")]
+        public class TestVolumeComponent0085 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1137742259);
+        }
+[SupportedOn(typeof(TestVolumeComponent0215))]
+[SupportedOn(typeof(TestVolumeComponent0234))]
+        public class TestVolumeComponent0086 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1413296044);
+        }
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0087 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(886779358);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0088 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(684313957);
+        }
+        public class TestVolumeComponent0089 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1319836461);
+        }
+[VolumeComponentMenu("Jrc/wd_C_YPtcMXboULGFSJpZbwGcbNCRdwxaIHKsKHdDUDxFhwYBAcdejgjuWFAFYkvFfs/zUPtLGTCwQLjsEkrTIovaAevF")]
+        public class TestVolumeComponent0090 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1438257597);
+        }
+[SupportedOn(typeof(TestVolumeComponent0144))]
+[VolumeComponentMenu("DEzpPIuYFEVYVxHtLAwYaMctNSVleC_vFrLtgnuhoSiUZfiv_U_bwxeGoEolRfVrwUTvkGXMRvXUcYqAPjqrubV gdwYFfqCXjTlDGqWJbJOVrDMwxixTGVfzlHQuSVrNSmxPEJQVKa")]
+        public class TestVolumeComponent0091 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1482740943);
+        }
+        public class TestVolumeComponent0092 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1448306715);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0093 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(190787262);
+        }
+[SupportedOn(typeof(TestVolumeComponent0142))]
+[SupportedOn(typeof(TestVolumeComponent0205))]
+[HideInInspector]
+        public class TestVolumeComponent0094 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(302373546);
+        }
+        public class TestVolumeComponent0095 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(274365877);
+        }
+        public class TestVolumeComponent0096 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1998419613);
+        }
+[SupportedOn(typeof(TestVolumeComponent0199))]
+[HideInInspector]
+        public class TestVolumeComponent0097 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(494137696);
+        }
+[SupportedOn(typeof(TestVolumeComponent0157))]
+[Obsolete]
+[VolumeComponentMenu("znTbTYcCiCoAHnPxmSN/Fvgdw")]
+        public class TestVolumeComponent0098 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1312800621);
+        }
+[SupportedOn(typeof(TestVolumeComponent0248))]
+[SupportedOn(typeof(TestVolumeComponent0339))]
+        public class TestVolumeComponent0099 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(737954698);
+        }
+[SupportedOn(typeof(TestVolumeComponent0236))]
+[SupportedOn(typeof(TestVolumeComponent0123))]
+[HideInInspector]
+        public class TestVolumeComponent0100 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(629842374);
+        }
+        public class TestVolumeComponent0101 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2096446553);
+        }
+[SupportedOn(typeof(TestVolumeComponent0275))]
+[SupportedOn(typeof(TestVolumeComponent0318))]
+[HideInInspector]
+[VolumeComponentMenu("wtm/kxRrwpqYBtHtPtz")]
+        public class TestVolumeComponent0102 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(297238543);
+        }
+[SupportedOn(typeof(TestVolumeComponent0128))]
+[Obsolete]
+        public class TestVolumeComponent0103 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(128402243);
+        }
+[SupportedOn(typeof(TestVolumeComponent0265))]
+[SupportedOn(typeof(TestVolumeComponent0348))]
+        public class TestVolumeComponent0104 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(363734876);
+        }
+[SupportedOn(typeof(TestVolumeComponent0213))]
+        public class TestVolumeComponent0105 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1619101752);
+        }
+        public class TestVolumeComponent0106 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(673911007);
+        }
+[SupportedOn(typeof(TestVolumeComponent0292))]
+[SupportedOn(typeof(TestVolumeComponent0295))]
+        public class TestVolumeComponent0107 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1446235616);
+        }
+        public class TestVolumeComponent0108 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1866168647);
+        }
+        public class TestVolumeComponent0109 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1733484307);
+        }
+[SupportedOn(typeof(TestVolumeComponent0192))]
+[SupportedOn(typeof(TestVolumeComponent0127))]
+[Obsolete]
+        public class TestVolumeComponent0110 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(971917231);
+        }
+[SupportedOn(typeof(TestVolumeComponent0200))]
+[SupportedOn(typeof(TestVolumeComponent0267))]
+        public class TestVolumeComponent0111 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(556578896);
+        }
+[SupportedOn(typeof(TestVolumeComponent0292))]
+[Obsolete]
+        public class TestVolumeComponent0112 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1267400252);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0113 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1626147587);
+        }
+[SupportedOn(typeof(TestVolumeComponent0164))]
+[HideInInspector]
+[VolumeComponentMenu("choGJETIcMREL")]
+        public class TestVolumeComponent0114 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(101472381);
+        }
+        public class TestVolumeComponent0115 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1442934277);
+        }
+[SupportedOn(typeof(TestVolumeComponent0234))]
+[VolumeComponentMenu(" cGaOXMmrofqEe/iMc/c DERjoAiOiUNjHbVdLYcxFhL zlHM_bTOLWNfmEoGsfsbRvJMTQBb_MTOXSB")]
+        public class TestVolumeComponent0116 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1476172269);
+        }
+[SupportedOn(typeof(TestVolumeComponent0266))]
+        public class TestVolumeComponent0117 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(801836497);
+        }
+[SupportedOn(typeof(TestVolumeComponent0275))]
+[SupportedOn(typeof(TestVolumeComponent0254))]
+[Obsolete]
+        public class TestVolumeComponent0118 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1269289542);
+        }
+[SupportedOn(typeof(TestVolumeComponent0247))]
+        public class TestVolumeComponent0119 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1037614226);
+        }
+[SupportedOn(typeof(TestVolumeComponent0336))]
+[HideInInspector]
+[VolumeComponentMenu("LYDrTARtcpivD mOXxF")]
+        public class TestVolumeComponent0120 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2075271823);
+        }
+[VolumeComponentMenu("CkjPpBrmWorFOJlFGBOexg cjiWZfutaSJxsnavZCkGBnZUNAqvRpmOPOsMw ofBMmYNbRSRMsKk")]
+        public class TestVolumeComponent0121 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1939288337);
+        }
+[SupportedOn(typeof(TestVolumeComponent0151))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0122 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1036197464);
+        }
+[SupportedOn(typeof(TestVolumeComponent0166))]
+[SupportedOn(typeof(TestVolumeComponent0137))]
+        public class TestVolumeComponent0123 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(730107837);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0124 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1086789184);
+        }
+[SupportedOn(typeof(TestVolumeComponent0273))]
+[SupportedOn(typeof(TestVolumeComponent0376))]
+        public class TestVolumeComponent0125 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(106198596);
+        }
+        public class TestVolumeComponent0126 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(343764232);
+        }
+[SupportedOn(typeof(TestVolumeComponent0355))]
+[SupportedOn(typeof(TestVolumeComponent0330))]
+        public class TestVolumeComponent0127 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1417421516);
+        }
+[SupportedOn(typeof(TestVolumeComponent0339))]
+[SupportedOn(typeof(TestVolumeComponent0262))]
+[Obsolete]
+        public class TestVolumeComponent0128 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(519517625);
+        }
+[Obsolete]
+        public class TestVolumeComponent0129 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1413482388);
+        }
+[SupportedOn(typeof(TestVolumeComponent0229))]
+[SupportedOn(typeof(TestVolumeComponent0216))]
+        public class TestVolumeComponent0130 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(727311073);
+        }
+[SupportedOn(typeof(TestVolumeComponent0337))]
+[SupportedOn(typeof(TestVolumeComponent0168))]
+        public class TestVolumeComponent0131 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(680356025);
+        }
+[SupportedOn(typeof(TestVolumeComponent0241))]
+[SupportedOn(typeof(TestVolumeComponent0156))]
+        public class TestVolumeComponent0132 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1805358894);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("zMZMglXUuKZfo/RQVhRdFQPpg")]
+        public class TestVolumeComponent0133 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(169602157);
+        }
+[SupportedOn(typeof(TestVolumeComponent0283))]
+        public class TestVolumeComponent0134 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(634417233);
+        }
+[SupportedOn(typeof(TestVolumeComponent0292))]
+[HideInInspector]
+        public class TestVolumeComponent0135 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1859538881);
+        }
+[SupportedOn(typeof(TestVolumeComponent0278))]
+[SupportedOn(typeof(TestVolumeComponent0237))]
+        public class TestVolumeComponent0136 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(960544089);
+        }
+[VolumeComponentMenu("")]
+        public class TestVolumeComponent0137 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(155843901);
+        }
+        public class TestVolumeComponent0138 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(520499013);
+        }
+[SupportedOn(typeof(TestVolumeComponent0385))]
+        public class TestVolumeComponent0139 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1063293617);
+        }
+[SupportedOn(typeof(TestVolumeComponent0250))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0140 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(668179604);
+        }
+[Obsolete]
+        public class TestVolumeComponent0141 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1518629955);
+        }
+[SupportedOn(typeof(TestVolumeComponent0303))]
+[SupportedOn(typeof(TestVolumeComponent0386))]
+        public class TestVolumeComponent0142 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(133044316);
+        }
+        public class TestVolumeComponent0143 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1711484331);
+        }
+[SupportedOn(typeof(TestVolumeComponent0257))]
+        public class TestVolumeComponent0144 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(92015071);
+        }
+        public class TestVolumeComponent0145 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(796010443);
+        }
+        public class TestVolumeComponent0146 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1197564602);
+        }
+[SupportedOn(typeof(TestVolumeComponent0290))]
+[SupportedOn(typeof(TestVolumeComponent0301))]
+        public class TestVolumeComponent0147 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1909525523);
+        }
+[SupportedOn(typeof(TestVolumeComponent0230))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("dkOFS_MRfiY_Wg/aUcSehcdirVIcdVMqKcxLCqEFOZU_ JvZCcpPxuOT TvaEsCF uAzIZjevZvNSXxBSZhqIHIXfHEPrq/ofuWwvwvkhsjexzlmbXOHxF/ZjBAHMLGmjPUzpLENpw")]
+        public class TestVolumeComponent0148 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(918797347);
+        }
+[SupportedOn(typeof(TestVolumeComponent0246))]
+[SupportedOn(typeof(TestVolumeComponent0201))]
+        public class TestVolumeComponent0149 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1718040828);
+        }
+[SupportedOn(typeof(TestVolumeComponent0322))]
+[HideInInspector]
+        public class TestVolumeComponent0150 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(72496779);
+        }
+        public class TestVolumeComponent0151 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1141999679);
+        }
+        public class TestVolumeComponent0152 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(347651286);
+        }
+[HideInInspector]
+[VolumeComponentMenu("RWVWZhHAF/JfgvVdFfm")]
+        public class TestVolumeComponent0153 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2064973711);
+        }
+[SupportedOn(typeof(TestVolumeComponent0179))]
+[SupportedOn(typeof(TestVolumeComponent0374))]
+[HideInInspector]
+        public class TestVolumeComponent0154 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(587446979);
+        }
+[Obsolete]
+        public class TestVolumeComponent0155 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(253448151);
+        }
+        public class TestVolumeComponent0156 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1745035886);
+        }
+[SupportedOn(typeof(TestVolumeComponent0244))]
+        public class TestVolumeComponent0157 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1119690706);
+        }
+[SupportedOn(typeof(TestVolumeComponent0349))]
+[SupportedOn(typeof(TestVolumeComponent0168))]
+        public class TestVolumeComponent0158 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(654981195);
+        }
+[SupportedOn(typeof(TestVolumeComponent0353))]
+        public class TestVolumeComponent0159 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1619639495);
+        }
+        public class TestVolumeComponent0160 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1527852990);
+        }
+[Obsolete]
+[VolumeComponentMenu("YiYohLtqbclPbcdXYupDdgQglzxJxedsYcxFAorsnL XQiOmWoMaYm BSebuEXOFlwtkIiKkSRKNIeEZCgheAHKaSLlBhFGedcjcpc NURpT LEPfDSzjkMVWcdXWoKRWHCarZKqfo")]
+        public class TestVolumeComponent0161 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1152652963);
+        }
+        public class TestVolumeComponent0162 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(887174775);
+        }
+        public class TestVolumeComponent0163 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(310732110);
+        }
+[SupportedOn(typeof(TestVolumeComponent0187))]
+[HideInInspector]
+        public class TestVolumeComponent0164 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1293709254);
+        }
+[SupportedOn(typeof(TestVolumeComponent0293))]
+        public class TestVolumeComponent0165 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(761485842);
+        }
+[SupportedOn(typeof(TestVolumeComponent0382))]
+[HideInInspector]
+[VolumeComponentMenu("XWeYc/NfJvwrsrDvsnD")]
+        public class TestVolumeComponent0166 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(791251471);
+        }
+[VolumeComponentMenu("rZUadXrsxBYDtFnVdHARCsGzKPvBbNKwADhsEztJxBnLbwdqUmtTbRdNKL/BMDpJ ojPQqKHxkrk")]
+        public class TestVolumeComponent0167 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(598414481);
+        }
+[SupportedOn(typeof(TestVolumeComponent0197))]
+[SupportedOn(typeof(TestVolumeComponent0176))]
+[HideInInspector]
+        public class TestVolumeComponent0168 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1649217941);
+        }
+[SupportedOn(typeof(TestVolumeComponent0398))]
+[SupportedOn(typeof(TestVolumeComponent0425))]
+        public class TestVolumeComponent0169 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1169466578);
+        }
+[SupportedOn(typeof(TestVolumeComponent0258))]
+        public class TestVolumeComponent0170 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(113516494);
+        }
+[SupportedOn(typeof(TestVolumeComponent0251))]
+[SupportedOn(typeof(TestVolumeComponent0378))]
+[Obsolete]
+        public class TestVolumeComponent0171 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1799859422);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0172 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1349006437);
+        }
+        public class TestVolumeComponent0173 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(986466861);
+        }
+[SupportedOn(typeof(TestVolumeComponent0308))]
+[SupportedOn(typeof(TestVolumeComponent0379))]
+[HideInInspector]
+        public class TestVolumeComponent0174 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1572793145);
+        }
+[Obsolete]
+        public class TestVolumeComponent0175 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1706022676);
+        }
+[SupportedOn(typeof(TestVolumeComponent0275))]
+[SupportedOn(typeof(TestVolumeComponent0262))]
+        public class TestVolumeComponent0176 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(985149537);
+        }
+[SupportedOn(typeof(TestVolumeComponent0383))]
+        public class TestVolumeComponent0177 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(46279965);
+        }
+[Obsolete]
+        public class TestVolumeComponent0178 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(260596192);
+        }
+[SupportedOn(typeof(TestVolumeComponent0238))]
+[Obsolete]
+[VolumeComponentMenu("XpBGw/kQsQDrTQTnetaYavTta")]
+        public class TestVolumeComponent0179 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(944002029);
+        }
+        public class TestVolumeComponent0180 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1081119445);
+        }
+[SupportedOn(typeof(TestVolumeComponent0203))]
+[SupportedOn(typeof(TestVolumeComponent0338))]
+[HideInInspector]
+        public class TestVolumeComponent0181 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1631454529);
+        }
+[SupportedOn(typeof(TestVolumeComponent0324))]
+        public class TestVolumeComponent0182 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1329396477);
+        }
+        public class TestVolumeComponent0183 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(982294656);
+        }
+[SupportedOn(typeof(TestVolumeComponent0307))]
+        public class TestVolumeComponent0184 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(13157124);
+        }
+        public class TestVolumeComponent0185 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(314441544);
+        }
+[VolumeComponentMenu("HKBAoOafzjFrLvB/LIs TGzWJWRvoGcvJ PbJ/RA_GJSNCuOzlwnPjwjexqr_nkMklqCJdDUm/alXANOLxJjefLOJCPleno")]
+        public class TestVolumeComponent0186 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1790781183);
+        }
+[SupportedOn(typeof(TestVolumeComponent0436))]
+[SupportedOn(typeof(TestVolumeComponent0311))]
+[Obsolete]
+        public class TestVolumeComponent0187 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1441899584);
+        }
+[SupportedOn(typeof(TestVolumeComponent0336))]
+[SupportedOn(typeof(TestVolumeComponent0439))]
+        public class TestVolumeComponent0188 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1010552900);
+        }
+[SupportedOn(typeof(TestVolumeComponent0384))]
+[SupportedOn(typeof(TestVolumeComponent0307))]
+[VolumeComponentMenu("ranPYLfFUshsnJUwtwAgSJKerVjwds/gOelLbqSDOulRKmOkOVpLEZAVxqWeMJSkUZWHAopufuf_l_fa")]
+        public class TestVolumeComponent0189 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1516021357);
+        }
+[SupportedOn(typeof(TestVolumeComponent0339))]
+[SupportedOn(typeof(TestVolumeComponent0430))]
+        public class TestVolumeComponent0190 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(80334474);
+        }
+[SupportedOn(typeof(TestVolumeComponent0327))]
+[Obsolete]
+        public class TestVolumeComponent0191 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(359347398);
+        }
+[SupportedOn(typeof(TestVolumeComponent0320))]
+        public class TestVolumeComponent0192 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(708640530);
+        }
+[SupportedOn(typeof(TestVolumeComponent0409))]
+[SupportedOn(typeof(TestVolumeComponent0424))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("kpuWspHjJWotaSXdgte")]
+        public class TestVolumeComponent0193 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(115193615);
+        }
+[VolumeComponentMenu("nXCcKmKsEHrq/uEo RCuIzdchelzI_ FtaMVjihujDKRYHMo qhkCB FGNMqYRUaMXjcIVMuxVAT")]
+        public class TestVolumeComponent0194 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2109122961);
+        }
+[SupportedOn(typeof(TestVolumeComponent0224))]
+[SupportedOn(typeof(TestVolumeComponent0203))]
+[HideInInspector]
+        public class TestVolumeComponent0195 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1230091925);
+        }
+[SupportedOn(typeof(TestVolumeComponent0425))]
+        public class TestVolumeComponent0196 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(422221465);
+        }
+[SupportedOn(typeof(TestVolumeComponent0242))]
+[SupportedOn(typeof(TestVolumeComponent0285))]
+        public class TestVolumeComponent0197 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1894402254);
+        }
+[SupportedOn(typeof(TestVolumeComponent0278))]
+[SupportedOn(typeof(TestVolumeComponent0405))]
+[Obsolete]
+        public class TestVolumeComponent0198 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(396014046);
+        }
+[SupportedOn(typeof(TestVolumeComponent0254))]
+[SupportedOn(typeof(TestVolumeComponent0217))]
+        public class TestVolumeComponent0199 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1784803183);
+        }
+[SupportedOn(typeof(TestVolumeComponent0370))]
+        public class TestVolumeComponent0200 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1337147291);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0201 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1393338942);
+        }
+[VolumeComponentMenu("ZdmdXUzxXbN/uCzEkQutRbDIDYkSHnDhZWZtmrgnJMzIRxzrutNUefDlztivPhzrPr_bebgQzlevVxVnPCaCPSXCmnRScMkYwIwvkbqxDdT FfVvZtPYPSurBtebBIwvBdHATSXxDdzboYR _EBSudzfoKuxLtclTMgAgCmUPAJhDv_pDdstcKeMkCZ/XpofmjJYgtmEepBSJYw/kxkrXrBKNhXxFAsEHfFKefwSsEi")]
+        public class TestVolumeComponent0202 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(713652431);
+        }
+        public class TestVolumeComponent0203 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(689746971);
+        }
+[SupportedOn(typeof(TestVolumeComponent0302))]
+        public class TestVolumeComponent0204 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(584325783);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0205 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1267238570);
+        }
+[SupportedOn(typeof(TestVolumeComponent0406))]
+        public class TestVolumeComponent0206 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1788118758);
+        }
+        public class TestVolumeComponent0207 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(168221625);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0208 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1291359584);
+        }
+[VolumeComponentMenu("vsvDnepRGBfqAN")]
+        public class TestVolumeComponent0209 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1249568111);
+        }
+[HideInInspector]
+[VolumeComponentMenu("J/TKcfVxHtDjcvDrR/BdPrkWLxPYglFSTdgYF/kIeYHOmtotZtmlm/LfRQqdPEFEFfDhB")]
+        public class TestVolumeComponent0210 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(497259277);
+        }
+[SupportedOn(typeof(TestVolumeComponent0424))]
+        public class TestVolumeComponent0211 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2014044145);
+        }
+[SupportedOn(typeof(TestVolumeComponent0433))]
+        public class TestVolumeComponent0212 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(537200373);
+        }
+[VolumeComponentMenu("UPvavcAX Fpcl_jonsbgvNOBpcMqCibJSwCoQDOgYut_vq/TKi/_rPpVEapmnqlox_SgdNCZWqYmETnurmrqAqfmfmvB ofeGgnJpLlXCVQPbupFpgnzWcS_hDSFtoMVEkpTYNtzjaGixTfJvzIahRWzIXdRlsMcKoKZSTUVCLrcMZniMibZ XfD")]
+        public class TestVolumeComponent0213 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1349379029);
+        }
+[SupportedOn(typeof(TestVolumeComponent0315))]
+[SupportedOn(typeof(TestVolumeComponent0342))]
+        public class TestVolumeComponent0214 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(268434);
+        }
+[SupportedOn(typeof(TestVolumeComponent0431))]
+[SupportedOn(typeof(TestVolumeComponent0446))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("gjuUe/TvuWRIatunL Z")]
+        public class TestVolumeComponent0215 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1614902927);
+        }
+[SupportedOn(typeof(TestVolumeComponent0241))]
+[SupportedOn(typeof(TestVolumeComponent0436))]
+[HideInInspector]
+        public class TestVolumeComponent0216 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1417760195);
+        }
+[SupportedOn(typeof(TestVolumeComponent0378))]
+[SupportedOn(typeof(TestVolumeComponent0461))]
+        public class TestVolumeComponent0217 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2110029788);
+        }
+[SupportedOn(typeof(TestVolumeComponent0326))]
+        public class TestVolumeComponent0218 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1945109688);
+        }
+[SupportedOn(typeof(TestVolumeComponent0287))]
+[SupportedOn(typeof(TestVolumeComponent0454))]
+        public class TestVolumeComponent0219 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1859161820);
+        }
+[SupportedOn(typeof(TestVolumeComponent0463))]
+[VolumeComponentMenu("HOkOsAP/PUFxads/aULWJQVnkpa VCuOPbFfTxVOmlTIHrwUzKFIZCJdwKq/aEkjNbZQPtBhR/u/_ANYNfzOXxPWNAHfsOu iMTEsjHWTEPQcKzEThZSVtHlNvkrsfPxNUHxwrmALjmATAZ LKzONERGR JxZvwW_WzCs NQcEJMc/kbuAFSHYRGmEaIe/wfH")]
+        public class TestVolumeComponent0220 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(728641853);
+        }
+        public class TestVolumeComponent0221 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(717110085);
+        }
+        public class TestVolumeComponent0222 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1911360232);
+        }
+[SupportedOn(typeof(TestVolumeComponent0298))]
+[SupportedOn(typeof(TestVolumeComponent0333))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0223 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1105381524);
+        }
+[SupportedOn(typeof(TestVolumeComponent0444))]
+[SupportedOn(typeof(TestVolumeComponent0307))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0224 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1469990979);
+        }
+[SupportedOn(typeof(TestVolumeComponent0386))]
+[SupportedOn(typeof(TestVolumeComponent0469))]
+        public class TestVolumeComponent0225 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1333060700);
+        }
+        public class TestVolumeComponent0226 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(815759787);
+        }
+        public class TestVolumeComponent0227 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1025783455);
+        }
+[SupportedOn(typeof(TestVolumeComponent0238))]
+        public class TestVolumeComponent0228 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(983868363);
+        }
+[SupportedOn(typeof(TestVolumeComponent0423))]
+[SupportedOn(typeof(TestVolumeComponent0294))]
+        public class TestVolumeComponent0229 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1382856263);
+        }
+[SupportedOn(typeof(TestVolumeComponent0303))]
+[SupportedOn(typeof(TestVolumeComponent0306))]
+[VolumeComponentMenu("taCVMkOHYRMZlPGuSFpuONYshBKmWFMTYmOaUoIREkl_QRpgvHlLM_po gvLvuhDveCkQXjXUwIZIT/HhsELxBCkt_CNYTYqEkAqvw/qpXhsEwKspV/ixPnNSBAqAgMkjwIibe _EuOXpFpedwrVbBlD u BdiOPfwlmpFfJSk/VKwODQq/JAqtBKuvPMorLAsjzYcKJtihPnclRYajBbLbZCghqrRnutJvXYNAubFWHQBMg/LlHnF")]
+        public class TestVolumeComponent0230 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1427307719);
+        }
+[SupportedOn(typeof(TestVolumeComponent0304))]
+        public class TestVolumeComponent0231 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1393523963);
+        }
+[SupportedOn(typeof(TestVolumeComponent0249))]
+[SupportedOn(typeof(TestVolumeComponent0268))]
+[HideInInspector]
+        public class TestVolumeComponent0232 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1727096623);
+        }
+        public class TestVolumeComponent0233 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(221824315);
+        }
+[SupportedOn(typeof(TestVolumeComponent0396))]
+        public class TestVolumeComponent0234 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1550107063);
+        }
+[SupportedOn(typeof(TestVolumeComponent0357))]
+[SupportedOn(typeof(TestVolumeComponent0468))]
+[HideInInspector]
+        public class TestVolumeComponent0235 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(414650499);
+        }
+[Obsolete]
+[VolumeComponentMenu("gIJpm XABWen_")]
+        public class TestVolumeComponent0236 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(994112509);
+        }
+[SupportedOn(typeof(TestVolumeComponent0418))]
+[SupportedOn(typeof(TestVolumeComponent0317))]
+[VolumeComponentMenu("SuIctuKFGZEkdmv_K_fDQuILrPUP VvzWsYurmxLdF qdznNdVYFbXbH/RxoOcjB/uOwvNIaOohzAkfcSwAP svwWZAunqCTlgEwAZCJdw/FpHbXvoYHYVSFSHU_OqhJhgfZCDnBMVEJWsxoWZpVQPfmIVrHbzloMBIXpmtcdJhZGqtXjqKkxipHWgjavPYDAs")]
+        public class TestVolumeComponent0237 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(286967675);
+        }
+[SupportedOn(typeof(TestVolumeComponent0255))]
+[SupportedOn(typeof(TestVolumeComponent0274))]
+[HideInInspector]
+        public class TestVolumeComponent0238 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(878261679);
+        }
+        public class TestVolumeComponent0239 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(696958395);
+        }
+[SupportedOn(typeof(TestVolumeComponent0402))]
+[SupportedOn(typeof(TestVolumeComponent0465))]
+[VolumeComponentMenu("_rsARruEuYPUZMeCHlevJpqERhzCoSwhutilwlk Nf_KovgnTbeSF/iWm/HdLKwdZMLAwdm gtLxR/wSHCH RlcSFlqUm/ahPbaMTCeOTjNU_bk")]
+        public class TestVolumeComponent0240 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1505452527);
+        }
+[SupportedOn(typeof(TestVolumeComponent0458))]
+[HideInInspector]
+        public class TestVolumeComponent0241 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1042994043);
+        }
+[SupportedOn(typeof(TestVolumeComponent0276))]
+        public class TestVolumeComponent0242 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2007741175);
+        }
+[SupportedOn(typeof(TestVolumeComponent0493))]
+[SupportedOn(typeof(TestVolumeComponent0348))]
+[Obsolete]
+        public class TestVolumeComponent0243 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(161519499);
+        }
+[SupportedOn(typeof(TestVolumeComponent0293))]
+        public class TestVolumeComponent0244 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1231474623);
+        }
+[SupportedOn(typeof(TestVolumeComponent0366))]
+[SupportedOn(typeof(TestVolumeComponent0497))]
+[HideInInspector]
+        public class TestVolumeComponent0245 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1919472883);
+        }
+[SupportedOn(typeof(TestVolumeComponent0247))]
+[SupportedOn(typeof(TestVolumeComponent0266))]
+[HideInInspector]
+        public class TestVolumeComponent0246 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1777099047);
+        }
+[SupportedOn(typeof(TestVolumeComponent0256))]
+        public class TestVolumeComponent0247 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(476940635);
+        }
+[SupportedOn(typeof(TestVolumeComponent0457))]
+[SupportedOn(typeof(TestVolumeComponent0348))]
+[Obsolete]
+        public class TestVolumeComponent0248 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1070718484);
+        }
+[SupportedOn(typeof(TestVolumeComponent0469))]
+[SupportedOn(typeof(TestVolumeComponent0332))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0249 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1068959683);
+        }
+[SupportedOn(typeof(TestVolumeComponent0411))]
+[SupportedOn(typeof(TestVolumeComponent0494))]
+        public class TestVolumeComponent0250 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1944628700);
+        }
+[SupportedOn(typeof(TestVolumeComponent0359))]
+[SupportedOn(typeof(TestVolumeComponent0478))]
+        public class TestVolumeComponent0251 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(180530360);
+        }
+        public class TestVolumeComponent0252 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1262188164);
+        }
+[SupportedOn(typeof(TestVolumeComponent0441))]
+        public class TestVolumeComponent0253 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1629458528);
+        }
+[SupportedOn(typeof(TestVolumeComponent0466))]
+        public class TestVolumeComponent0254 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(398840652);
+        }
+[SupportedOn(typeof(TestVolumeComponent0331))]
+[VolumeComponentMenu("CVUZMovZnLbeAuQZEXnapatzrohkhcUcdJtJpqYHMBpBOqWPIg/PQLKaSmd_xHdLIujsjiYafJGkfonahXUDxF/qtBKDhRfmnZjDlo/BpmYZOHjulkQHhmbmOmUadaQLdN/VhiCmSV VYiGT/ZpDEipV HxV/JfVvsEeOL _vqpehLjivaKBYaMkGoCBCufwdqSDt_jzfDdXxmGeKVUqngvqlqURdLOLYTQPMiSoQmUPONjcQmnZ/R")]
+        public class TestVolumeComponent0255 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(940064839);
+        }
+[SupportedOn(typeof(TestVolumeComponent0329))]
+        public class TestVolumeComponent0256 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1037954171);
+        }
+[SupportedOn(typeof(TestVolumeComponent0274))]
+[SupportedOn(typeof(TestVolumeComponent0293))]
+[HideInInspector]
+        public class TestVolumeComponent0257 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2096043695);
+        }
+[SupportedOn(typeof(TestVolumeComponent0347))]
+        public class TestVolumeComponent0258 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1741987811);
+        }
+[SupportedOn(typeof(TestVolumeComponent0484))]
+[SupportedOn(typeof(TestVolumeComponent0439))]
+[Obsolete]
+        public class TestVolumeComponent0259 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(771067196);
+        }
+[SupportedOn(typeof(TestVolumeComponent0304))]
+[SupportedOn(typeof(TestVolumeComponent0295))]
+[HideInInspector]
+[VolumeComponentMenu("G_AuvaAcWchXYZpZnBdNERWVtVWgEzYH eSzfgANbDpHxTfgCwWHCFOPpRrLIuMTIolwnghqOVSHKROuGPvHv_KehN/Bb_t_lPWVYVOF JUZOHIq mdolovwfTfsITMDhcrHEzSXhF qOkdPdqjDUa")]
+        public class TestVolumeComponent0260 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1968420391);
+        }
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0261 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(339027578);
+        }
+[SupportedOn(typeof(TestVolumeComponent0366))]
+        public class TestVolumeComponent0262 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1976768694);
+        }
+[SupportedOn(typeof(TestVolumeComponent0359))]
+[HideInInspector]
+[VolumeComponentMenu("cImEzKFIa VxgtmAZjsINWHhZdajo/JOaSB JCo/eQJ FdelelFjVjuGgboQcKTn_ALfNQFGzKFCclBxz eIBjDjBCeSehVOmUPpeYTEsfu/NpztkvPbahaQoxeGTxLUzpuhav_CqbJI_/ahmMzQJKPOcjuAJjNYX aYzjcrznwGVQT itNfN _vFrZrodi/LtHlHjL uAXdNnshulqfm/VxshF")]
+        public class TestVolumeComponent0263 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1268987711);
+        }
+[VolumeComponentMenu(" ZY_vwIHCmxo utBG_YaWFKPj_ENQJQDQmx_ FAFrPG_CojFYR anRbibHSZnolRdzQ_GaAV wCwQmUDnD VABAPKZfqOPAoENhcvVMeQZ/sdNQZCBIe aGB eWmYNUTGqQHQZxzxsYVEaOPtgOFKgdHUoCTIZAoGH/XWRvslFOJ")]
+        public class TestVolumeComponent0264 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(396955697);
+        }
+[SupportedOn(typeof(TestVolumeComponent0358))]
+        public class TestVolumeComponent0265 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1109440565);
+        }
+[SupportedOn(typeof(TestVolumeComponent0303))]
+[SupportedOn(typeof(TestVolumeComponent0458))]
+        public class TestVolumeComponent0266 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(588300466);
+        }
+        public class TestVolumeComponent0267 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(868583965);
+        }
+[SupportedOn(typeof(TestVolumeComponent0513))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("wGFtZWPWcGXOwAPjJOXfTlzjw")]
+        public class TestVolumeComponent0268 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1868661229);
+        }
+[SupportedOn(typeof(TestVolumeComponent0418))]
+[SupportedOn(typeof(TestVolumeComponent0509))]
+        public class TestVolumeComponent0269 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1438181386);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0270 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1806053185);
+        }
+[SupportedOn(typeof(TestVolumeComponent0413))]
+        public class TestVolumeComponent0271 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(426988797);
+        }
+[SupportedOn(typeof(TestVolumeComponent0310))]
+[SupportedOn(typeof(TestVolumeComponent0445))]
+[Obsolete]
+[VolumeComponentMenu("XIXpodPQJreSqKL VhD")]
+        public class TestVolumeComponent0272 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2045438607);
+        }
+[SupportedOn(typeof(TestVolumeComponent0298))]
+[SupportedOn(typeof(TestVolumeComponent0493))]
+[HideInInspector]
+        public class TestVolumeComponent0273 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(621920707);
+        }
+[SupportedOn(typeof(TestVolumeComponent0435))]
+[HideInInspector]
+        public class TestVolumeComponent0274 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(831522519);
+        }
+[SupportedOn(typeof(TestVolumeComponent0461))]
+        public class TestVolumeComponent0275 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1544720547);
+        }
+[SupportedOn(typeof(TestVolumeComponent0390))]
+[SupportedOn(typeof(TestVolumeComponent0389))]
+        public class TestVolumeComponent0276 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(833282911);
+        }
+        public class TestVolumeComponent0277 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(736999243);
+        }
+        public class TestVolumeComponent0278 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(240033850);
+        }
+        public class TestVolumeComponent0279 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(194470746);
+        }
+[SupportedOn(typeof(TestVolumeComponent0320))]
+[Obsolete]
+[VolumeComponentMenu("QutP kv_QcOgSPARlFSoKzvF/gOcfaMzliE_CqnJWq TGTjLhBONKJCmrwG_lDAmrTQkGVnRIFEuUsIZKgYJSBp_IBQuQVKzjo/iCmCeAinLdN/DbDQT/ojgbDvDUkMkGwfovNhsdD")]
+        public class TestVolumeComponent0280 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1098409379);
+        }
+[SupportedOn(typeof(TestVolumeComponent0378))]
+[SupportedOn(typeof(TestVolumeComponent0333))]
+        public class TestVolumeComponent0281 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1345977468);
+        }
+[SupportedOn(typeof(TestVolumeComponent0454))]
+[HideInInspector]
+        public class TestVolumeComponent0282 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(266338315);
+        }
+[SupportedOn(typeof(TestVolumeComponent0332))]
+        public class TestVolumeComponent0283 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(622453823);
+        }
+[VolumeComponentMenu("CwfzCHjaxkhJOXIXhoxqYZrRbRvBENbBh_lFhRQZSRAHYPEXv_lcri/srgC_tqxgUiUHEVjavwIwOeIkriIBbzE_bm inNKBOmlwjmMwWqtuM_SkfFfuYmUgOVMF/VYaAZWaAch_vLOXbZWTn_ JdixPIPbVxDAkSNMZvTYeGiMT")]
+        public class TestVolumeComponent0284 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(826288433);
+        }
+[SupportedOn(typeof(TestVolumeComponent0378))]
+        public class TestVolumeComponent0285 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2086020405);
+        }
+[SupportedOn(typeof(TestVolumeComponent0323))]
+[SupportedOn(typeof(TestVolumeComponent0478))]
+        public class TestVolumeComponent0286 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1449273778);
+        }
+[SupportedOn(typeof(TestVolumeComponent0311))]
+[SupportedOn(typeof(TestVolumeComponent0454))]
+        public class TestVolumeComponent0287 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1408791802);
+        }
+[SupportedOn(typeof(TestVolumeComponent0303))]
+[VolumeComponentMenu("VpJQmOJOVfTEija/eQJdsbLARneADrNSclP/itZfTWXQoKkYwb_WX")]
+        public class TestVolumeComponent0288 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1259180989);
+        }
+[SupportedOn(typeof(TestVolumeComponent0342))]
+[SupportedOn(typeof(TestVolumeComponent0497))]
+[Obsolete]
+        public class TestVolumeComponent0289 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2082268282);
+        }
+[SupportedOn(typeof(TestVolumeComponent0394))]
+[SupportedOn(typeof(TestVolumeComponent0473))]
+        public class TestVolumeComponent0290 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(762040962);
+        }
+[SupportedOn(typeof(TestVolumeComponent0322))]
+[HideInInspector]
+        public class TestVolumeComponent0291 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(75346690);
+        }
+[SupportedOn(typeof(TestVolumeComponent0476))]
+        public class TestVolumeComponent0292 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1998291710);
+        }
+        public class TestVolumeComponent0293 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1501935473);
+        }
+        public class TestVolumeComponent0294 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(558816033);
+        }
+[SupportedOn(typeof(TestVolumeComponent0373))]
+[VolumeComponentMenu("hXUHbDlDMsMqQRfenDtRGNEuEzAiKLWwKHfBOB evHOilXjZIHIBIwYwleSJYuIJGmC_ Tjq mGmhBAoSwduhN/NYqCwtw/JEP/FCwpNxgAPKRQe _/gOsWmUFCLWDbLxHpwOFYXOFQaIaGXhaKHvktorm/svNnmpm RpNbDMoxmvwKoKiliMibD")]
+        public class TestVolumeComponent0295 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(644010837);
+        }
+[SupportedOn(typeof(TestVolumeComponent0397))]
+[SupportedOn(typeof(TestVolumeComponent0424))]
+        public class TestVolumeComponent0296 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(236134930);
+        }
+[Obsolete]
+[VolumeComponentMenu("qYBMkYPMNliUHhzrcfF")]
+        public class TestVolumeComponent0297 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1568903695);
+        }
+[SupportedOn(typeof(TestVolumeComponent0323))]
+[Obsolete]
+        public class TestVolumeComponent0298 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1786615107);
+        }
+[Obsolete]
+        public class TestVolumeComponent0299 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(175968343);
+        }
+[SupportedOn(typeof(TestVolumeComponent0486))]
+[SupportedOn(typeof(TestVolumeComponent0469))]
+        public class TestVolumeComponent0300 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(771378859);
+        }
+[SupportedOn(typeof(TestVolumeComponent0414))]
+[SupportedOn(typeof(TestVolumeComponent0369))]
+        public class TestVolumeComponent0301 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(5241348);
+        }
+[SupportedOn(typeof(TestVolumeComponent0490))]
+[SupportedOn(typeof(TestVolumeComponent0545))]
+[VolumeComponentMenu("LSqlaEalXhu/mSurFrLfm c inDjgvVAVEe/zKVEPIHlmKZbwlBnebglJUZ iWZUstBrDpgUBWLYLWZE_IZfVncdZUuhaniQaADvkdDGNAebXGVlRKapNIV LxmdFbmIgjmAkxTfw/N LGHIZtwEc RbPxshJlTxqMDxiARIiUgxDEcnkOTGwYZbLYRfotBAH")]
+        public class TestVolumeComponent0302 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(520709309);
+        }
+        public class TestVolumeComponent0303 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(210105541);
+        }
+[SupportedOn(typeof(TestVolumeComponent0550))]
+[SupportedOn(typeof(TestVolumeComponent0365))]
+        public class TestVolumeComponent0304 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1616625061);
+        }
+[SupportedOn(typeof(TestVolumeComponent0310))]
+[HideInInspector]
+[VolumeComponentMenu("jwIRfHlVdFvcOij_hktkrRUD")]
+        public class TestVolumeComponent0305 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(13966197);
+        }
+[SupportedOn(typeof(TestVolumeComponent0471))]
+[SupportedOn(typeof(TestVolumeComponent0370))]
+[HideInInspector]
+        public class TestVolumeComponent0306 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1422035577);
+        }
+[SupportedOn(typeof(TestVolumeComponent0544))]
+[SupportedOn(typeof(TestVolumeComponent0459))]
+        public class TestVolumeComponent0307 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2126628974);
+        }
+[SupportedOn(typeof(TestVolumeComponent0452))]
+[SupportedOn(typeof(TestVolumeComponent0451))]
+        public class TestVolumeComponent0308 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(822515902);
+        }
+[Obsolete]
+[VolumeComponentMenu("WDKqCiUkSX TYPCDCi ZMejXORdmrFxTUeviWzQglzSHvFrDI_xojXhDYREHABC_vNOzQZAun_SDUcCcjFnXCPOz stTvZYFvFKJSgpqlR/orq/XIZYsvuYcna TUVSVtaCNtwEFpz")]
+        public class TestVolumeComponent0309 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1129357219);
+        }
+[SupportedOn(typeof(TestVolumeComponent0407))]
+[SupportedOn(typeof(TestVolumeComponent0362))]
+        public class TestVolumeComponent0310 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(861371004);
+        }
+[SupportedOn(typeof(TestVolumeComponent0483))]
+[SupportedOn(typeof(TestVolumeComponent0474))]
+[VolumeComponentMenu("TQaUcCofoWNELfTSNxJbo FjVjRvPxRWVMDIuvkbcSufuMVE_jwtcOkSkADEcGoQw/DMTxaQBfkKoMDbzKzQzbaMBKqGTdBGc/kUXpejBYs/qboreIaxVpzIo k/sMsjPhzANQaGZbiQDUgYXSLxwKJKTtPAXUR _O_rRKsUwlwjzSzxT")]
+        public class TestVolumeComponent0311 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2002830669);
+        }
+[SupportedOn(typeof(TestVolumeComponent0397))]
+[SupportedOn(typeof(TestVolumeComponent0360))]
+[Obsolete]
+        public class TestVolumeComponent0312 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(760509994);
+        }
+        public class TestVolumeComponent0313 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2105376565);
+        }
+[SupportedOn(typeof(TestVolumeComponent0351))]
+[SupportedOn(typeof(TestVolumeComponent0506))]
+        public class TestVolumeComponent0314 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(633980850);
+        }
+[SupportedOn(typeof(TestVolumeComponent0339))]
+        public class TestVolumeComponent0315 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1500159406);
+        }
+[SupportedOn(typeof(TestVolumeComponent0332))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("jTQFOcGHQB/aYa/sQLvklDSPtFjLtzlFdeIwCgCF/DtV DpFUwnDtJYolFMoGkOwQmfFIF/_rcxaxmraAHCHKcOFjwWzlkvZvzIZKebJj_pTOu wYTfgrkWoWstHhDpNMFQ_bHrcEDpTtuAujJfTYZKLpLKaQeQijzlBdDAw ensUFEiSXALUqQkliWa/VxabaQzlD V")]
+        public class TestVolumeComponent0316 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(734367717);
+        }
+[SupportedOn(typeof(TestVolumeComponent0450))]
+        public class TestVolumeComponent0317 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(276570089);
+        }
+[SupportedOn(typeof(TestVolumeComponent0523))]
+[HideInInspector]
+        public class TestVolumeComponent0318 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(657040569);
+        }
+[SupportedOn(typeof(TestVolumeComponent0445))]
+[HideInInspector]
+        public class TestVolumeComponent0319 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1587775124);
+        }
+        public class TestVolumeComponent0320 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(791307128);
+        }
+[SupportedOn(typeof(TestVolumeComponent0517))]
+[Obsolete]
+        public class TestVolumeComponent0321 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(395240516);
+        }
+        public class TestVolumeComponent0322 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1758467795);
+        }
+        public class TestVolumeComponent0323 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1073652615);
+        }
+[VolumeComponentMenu("PtJAeYmpDjPWT/mMNMXf_CmOLtPfXbqCJSBhavFCJKV oGBKkUXAV")]
+        public class TestVolumeComponent0324 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(903071805);
+        }
+[SupportedOn(typeof(TestVolumeComponent0378))]
+[VolumeComponentMenu("aYLrqWDhedNGFrcpXQkWNtNrmYepFMHjV s/_hLxNxclXlgWinqnPpVWzYNMZWPxkfg/RIXdofcEgpFbHKeIafidPIPpNKTnmxaCwOLfiQajmvqAgUcSXnFOLKoxqCeURAFfmCiYiKP")]
+        public class TestVolumeComponent0325 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(872762191);
+        }
+        public class TestVolumeComponent0326 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2117667995);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0327 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1591528254);
+        }
+[VolumeComponentMenu("N/_MJSDQqOXMZSeAZdXImUmbTEqvDdkEq RbVtZYenafV kUcjcdspcSRSFnkSB VnaCs/atNYBKcYcCqdeELnTpgKRYH/sx_ kYZCD zELjJve/PrNSVSzSVjZOPWgdDIzO_nXOZIJUVdidmMDWstHdLKPUkUHYgrV oxDQPjwbDOTnk/qMghNQRfuMqbB zfoAkULpqpmtJxDjZbXtmUeKVKcfuYqI_bwAenXlRUJ")]
+        public class TestVolumeComponent0328 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1548734927);
+        }
+[SupportedOn(typeof(TestVolumeComponent0482))]
+[SupportedOn(typeof(TestVolumeComponent0421))]
+        public class TestVolumeComponent0329 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2061558448);
+        }
+        public class TestVolumeComponent0330 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(781620023);
+        }
+        public class TestVolumeComponent0331 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1691287395);
+        }
+[SupportedOn(typeof(TestVolumeComponent0574))]
+        public class TestVolumeComponent0332 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1005340383);
+        }
+[SupportedOn(typeof(TestVolumeComponent0471))]
+        public class TestVolumeComponent0333 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(276160779);
+        }
+        public class TestVolumeComponent0334 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1349344890);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("ScQiUcpq/V krZdm/X/exDdmjstPSzYPlNxsCudLlNAgxmbJreQVvJUZKPhJvDdXOBfJdzOuvVKeKkvZKmWXxaIDYkQzAiQolwCRdBhHfiKTMaAB/wE_AVKepJWiIqAgYJxJAZKzKirJdzQqhktHYzABhkMXWcKJIiYFtqtNARCFlH gbkpgdLONlFCZERINhHlohzYz")]
+        public class TestVolumeComponent0335 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1188123493);
+        }
+[SupportedOn(typeof(TestVolumeComponent0469))]
+        public class TestVolumeComponent0336 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1527194473);
+        }
+[Obsolete]
+        public class TestVolumeComponent0337 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(767482425);
+        }
+[SupportedOn(typeof(TestVolumeComponent0464))]
+[HideInInspector]
+        public class TestVolumeComponent0338 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2083245588);
+        }
+[SupportedOn(typeof(TestVolumeComponent0438))]
+[SupportedOn(typeof(TestVolumeComponent0425))]
+        public class TestVolumeComponent0339 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(148119393);
+        }
+[SupportedOn(typeof(TestVolumeComponent0546))]
+[SupportedOn(typeof(TestVolumeComponent0377))]
+        public class TestVolumeComponent0340 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(379572025);
+        }
+[SupportedOn(typeof(TestVolumeComponent0450))]
+        public class TestVolumeComponent0341 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(360428317);
+        }
+[HideInInspector]
+[VolumeComponentMenu("c DjcG_QNUubPIgSVAixFpzKs")]
+        public class TestVolumeComponent0342 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1484602093);
+        }
+        public class TestVolumeComponent0343 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(340982229);
+        }
+[SupportedOn(typeof(TestVolumeComponent0366))]
+[SupportedOn(typeof(TestVolumeComponent0501))]
+[HideInInspector]
+        public class TestVolumeComponent0344 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(634638401);
+        }
+        public class TestVolumeComponent0345 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(716071996);
+        }
+[SupportedOn(typeof(TestVolumeComponent0525))]
+        public class TestVolumeComponent0346 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2120551296);
+        }
+[SupportedOn(typeof(TestVolumeComponent0470))]
+        public class TestVolumeComponent0347 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(351349252);
+        }
+        public class TestVolumeComponent0348 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2031877704);
+        }
+[SupportedOn(typeof(TestVolumeComponent0449))]
+[SupportedOn(typeof(TestVolumeComponent0424))]
+[HideInInspector]
+        public class TestVolumeComponent0349 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1509327124);
+        }
+[SupportedOn(typeof(TestVolumeComponent0570))]
+[SupportedOn(typeof(TestVolumeComponent0433))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0350 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(224544451);
+        }
+[SupportedOn(typeof(TestVolumeComponent0512))]
+[SupportedOn(typeof(TestVolumeComponent0595))]
+        public class TestVolumeComponent0351 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2010589404);
+        }
+[SupportedOn(typeof(TestVolumeComponent0460))]
+[SupportedOn(typeof(TestVolumeComponent0579))]
+        public class TestVolumeComponent0352 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(745485240);
+        }
+[SupportedOn(typeof(TestVolumeComponent0588))]
+        public class TestVolumeComponent0353 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(935291868);
+        }
+[SupportedOn(typeof(TestVolumeComponent0597))]
+[SupportedOn(typeof(TestVolumeComponent0584))]
+[Obsolete]
+        public class TestVolumeComponent0354 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(688258025);
+        }
+        public class TestVolumeComponent0355 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1108696228);
+        }
+[SupportedOn(typeof(TestVolumeComponent0487))]
+[Obsolete]
+        public class TestVolumeComponent0356 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1929547528);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0357 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(324505391);
+        }
+        public class TestVolumeComponent0358 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1715408187);
+        }
+[SupportedOn(typeof(TestVolumeComponent0521))]
+[SupportedOn(typeof(TestVolumeComponent0584))]
+[VolumeComponentMenu("aEwE_tHxVABGcGDYedJUTMZQgvsdPvBlNSN RMavHrBKkMqli/zSkjRAH TGuIsSVMDhqhoKLUz/R/oIXQeCXjgQHYsMXITCTAmCDEcnRYLMTxu")]
+        public class TestVolumeComponent0359 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1225127791);
+        }
+[HideInInspector]
+[VolumeComponentMenu("NbedNCqA_ PrX/gCBbD JYoMBCebXAabcdHWebBnop_SHOL/P cUDxkSHnsIeGPQghVjF")]
+        public class TestVolumeComponent0360 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1223345421);
+        }
+        public class TestVolumeComponent0361 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(846181429);
+        }
+[SupportedOn(typeof(TestVolumeComponent0576))]
+        public class TestVolumeComponent0362 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1176159137);
+        }
+[SupportedOn(typeof(TestVolumeComponent0441))]
+[VolumeComponentMenu("dHjHfspTxoANKaOiAsMaSXIoOBtwjcCTdBnZGBrwlahz XKmCPpFU_GurujDvofXScjZCHfuhPbuCqdqSaOwfzrgpktPnTvLETMebNWRt_GavuKcAirzSFra/RAcWk/NWqh_toAVvuIDUTWuCiWFfuQ_EPMeUmCohZxXKeMHCmIJpXjNnJnHfiMo")]
+        public class TestVolumeComponent0363 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(600167893);
+        }
+        public class TestVolumeComponent0364 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(82095869);
+        }
+        public class TestVolumeComponent0365 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(273255552);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0366 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(976226599);
+        }
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0367 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1124475258);
+        }
+        public class TestVolumeComponent0368 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1825489317);
+        }
+[SupportedOn(typeof(TestVolumeComponent0374))]
+[HideInInspector]
+[VolumeComponentMenu("UVIoMLUTWmx_pzOibFCJMZUF")]
+        public class TestVolumeComponent0369 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(460058485);
+        }
+[SupportedOn(typeof(TestVolumeComponent0535))]
+[Obsolete]
+        public class TestVolumeComponent0370 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1932578425);
+        }
+[SupportedOn(typeof(TestVolumeComponent0608))]
+[SupportedOn(typeof(TestVolumeComponent0523))]
+        public class TestVolumeComponent0371 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1046856814);
+        }
+[SupportedOn(typeof(TestVolumeComponent0516))]
+[SupportedOn(typeof(TestVolumeComponent0515))]
+        public class TestVolumeComponent0372 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1644010686);
+        }
+[SupportedOn(typeof(TestVolumeComponent0620))]
+[HideInInspector]
+[VolumeComponentMenu("pXGZvTIchkOsKqGklqpiS_WHSFteOkEaQBjBONCFEFKsEutohZCujDGeOHSuKR/urB odPbzAuQoWorZjDGsKq L/NfZbqILUJjuMVUovkhVQF LlVrudgINfDEcQkxaQJSRnBYgUF")]
+        public class TestVolumeComponent0373 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1143128995);
+        }
+[SupportedOn(typeof(TestVolumeComponent0471))]
+        public class TestVolumeComponent0374 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1682287063);
+        }
+[SupportedOn(typeof(TestVolumeComponent0480))]
+[SupportedOn(typeof(TestVolumeComponent0547))]
+[HideInInspector]
+        public class TestVolumeComponent0375 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1382211083);
+        }
+[SupportedOn(typeof(TestVolumeComponent0425))]
+        public class TestVolumeComponent0376 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1708421695);
+        }
+[SupportedOn(typeof(TestVolumeComponent0498))]
+[SupportedOn(typeof(TestVolumeComponent0629))]
+[HideInInspector]
+        public class TestVolumeComponent0377 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1804625779);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("dzYujZjs/u/cOgv_MNxsUZMVYDMDWVQivkYunLMgGR/BERpwnBOFYwncMiSNdZS_vRtNbRU_GsvVSHKiWz ajNOgMT/aCBWNERMqvRSPncdJdiUwbwvRUBnTrk")]
+        public class TestVolumeComponent0378 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1494049203);
+        }
+[SupportedOn(typeof(TestVolumeComponent0508))]
+        public class TestVolumeComponent0379 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(508600551);
+        }
+[SupportedOn(typeof(TestVolumeComponent0517))]
+[SupportedOn(typeof(TestVolumeComponent0392))]
+        public class TestVolumeComponent0380 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(137022344);
+        }
+[SupportedOn(typeof(TestVolumeComponent0609))]
+        public class TestVolumeComponent0381 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1003734356);
+        }
+[SupportedOn(typeof(TestVolumeComponent0474))]
+        public class TestVolumeComponent0382 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(998583600);
+        }
+[SupportedOn(typeof(TestVolumeComponent0499))]
+[SupportedOn(typeof(TestVolumeComponent0538))]
+[Obsolete]
+        public class TestVolumeComponent0383 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1970636820);
+        }
+[SupportedOn(typeof(TestVolumeComponent0483))]
+[SupportedOn(typeof(TestVolumeComponent0470))]
+        public class TestVolumeComponent0384 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1862225249);
+        }
+[SupportedOn(typeof(TestVolumeComponent0591))]
+[SupportedOn(typeof(TestVolumeComponent0422))]
+        public class TestVolumeComponent0385 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(278919481);
+        }
+[SupportedOn(typeof(TestVolumeComponent0495))]
+        public class TestVolumeComponent0386 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1517636893);
+        }
+[SupportedOn(typeof(TestVolumeComponent0632))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("ufJYmMNbetmdTWs FjoCcvZKZ")]
+        public class TestVolumeComponent0387 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2080842989);
+        }
+[SupportedOn(typeof(TestVolumeComponent0537))]
+        public class TestVolumeComponent0388 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(394278097);
+        }
+[Obsolete]
+        public class TestVolumeComponent0389 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1576631873);
+        }
+[SupportedOn(typeof(TestVolumeComponent0532))]
+        public class TestVolumeComponent0390 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(67996669);
+        }
+        public class TestVolumeComponent0391 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2030634368);
+        }
+[SupportedOn(typeof(TestVolumeComponent0515))]
+[SupportedOn(typeof(TestVolumeComponent0422))]
+        public class TestVolumeComponent0392 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1190113733);
+        }
+        public class TestVolumeComponent0393 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1348686696);
+        }
+[SupportedOn(typeof(TestVolumeComponent0469))]
+[SupportedOn(typeof(TestVolumeComponent0504))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0394 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1655164692);
+        }
+[SupportedOn(typeof(TestVolumeComponent0615))]
+[HideInInspector]
+        public class TestVolumeComponent0395 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2002251971);
+        }
+[SupportedOn(typeof(TestVolumeComponent0557))]
+[HideInInspector]
+        public class TestVolumeComponent0396 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(326099415);
+        }
+[SupportedOn(typeof(TestVolumeComponent0583))]
+        public class TestVolumeComponent0397 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1520907171);
+        }
+[SupportedOn(typeof(TestVolumeComponent0512))]
+[SupportedOn(typeof(TestVolumeComponent0511))]
+        public class TestVolumeComponent0398 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1348486751);
+        }
+[SupportedOn(typeof(TestVolumeComponent0584))]
+        public class TestVolumeComponent0399 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1283164051);
+        }
+        public class TestVolumeComponent0400 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(630369991);
+        }
+[SupportedOn(typeof(TestVolumeComponent0555))]
+[SupportedOn(typeof(TestVolumeComponent0474))]
+        public class TestVolumeComponent0401 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(471621371);
+        }
+[SupportedOn(typeof(TestVolumeComponent0419))]
+[Obsolete]
+        public class TestVolumeComponent0402 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1187170607);
+        }
+[SupportedOn(typeof(TestVolumeComponent0492))]
+[SupportedOn(typeof(TestVolumeComponent0559))]
+        public class TestVolumeComponent0403 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2065447888);
+        }
+[VolumeComponentMenu("PtTjmjidmIsIwlalJOqfXAV/oIqpkYsfsMghTIaAkpcKVlVtHSNlB/zULELpoKkvk/FWHULY_nFYwvatetslatuOsYDYwdeWurPQBQwGm PvRhT")]
+        public class TestVolumeComponent0404 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1132343663);
+        }
+[SupportedOn(typeof(TestVolumeComponent0622))]
+[HideInInspector]
+        public class TestVolumeComponent0405 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(757115131);
+        }
+[SupportedOn(typeof(TestVolumeComponent0440))]
+        public class TestVolumeComponent0406 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(626337911);
+        }
+[SupportedOn(typeof(TestVolumeComponent0657))]
+[SupportedOn(typeof(TestVolumeComponent0512))]
+[Obsolete]
+        public class TestVolumeComponent0407 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(505465611);
+        }
+[SupportedOn(typeof(TestVolumeComponent0457))]
+        public class TestVolumeComponent0408 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1775812415);
+        }
+[SupportedOn(typeof(TestVolumeComponent0530))]
+[Obsolete]
+        public class TestVolumeComponent0409 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(237937779);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("CBCTxkvqWZCwvijHfH/VMVruOsWiSPdinincQZSit_lFYPWs iK_havHdsGstVCFEcjevNCN/ZARbHbuOBxZfwOFlRQTrDfkQwEFGghJCwKktPAqbDnBjFjVtD")]
+        public class TestVolumeComponent0410 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1048343219);
+        }
+        public class TestVolumeComponent0411 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1401626919);
+        }
+[Obsolete]
+        public class TestVolumeComponent0412 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(569565918);
+        }
+[SupportedOn(typeof(TestVolumeComponent0468))]
+[SupportedOn(typeof(TestVolumeComponent0431))]
+        public class TestVolumeComponent0413 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2085709935);
+        }
+[SupportedOn(typeof(TestVolumeComponent0584))]
+[SupportedOn(typeof(TestVolumeComponent0567))]
+        public class TestVolumeComponent0414 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1053824899);
+        }
+[SupportedOn(typeof(TestVolumeComponent0448))]
+[SupportedOn(typeof(TestVolumeComponent0531))]
+[VolumeComponentMenu("WLIzMarBAFfarVdJlJrkEBra/qGqjLlclmrgpBxiY_KwSDfXOeOmhFt_Is mKJSZEPrLpHjwQRKwEwdzjcxHATYmjkxLALQFhmbDrivgbwxujV")]
+        public class TestVolumeComponent0415 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(221966991);
+        }
+[VolumeComponentMenu("QZWHQcEaxRGe/JdwKsIZMoOsdDGqbHMqEzULhgOFfPWRfVYutX/kANWkxXAc/XSBvznufJnunuvo")]
+        public class TestVolumeComponent0416 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1549730065);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0417 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1288793688);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0418 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1228848383);
+        }
+[SupportedOn(typeof(TestVolumeComponent0668))]
+[VolumeComponentMenu("RURx_hkABCaEzfcdXWXjwxmpmOPIB/iGwKcWiQVrBtVWiSRdc/kATbolTdqSFjmjefajwKLjqMT eQ_AenonkCe")]
+        public class TestVolumeComponent0419 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1615281775);
+        }
+[SupportedOn(typeof(TestVolumeComponent0637))]
+[SupportedOn(typeof(TestVolumeComponent0448))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0420 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(405413371);
+        }
+[SupportedOn(typeof(TestVolumeComponent0455))]
+        public class TestVolumeComponent0421 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1850106231);
+        }
+[SupportedOn(typeof(TestVolumeComponent0672))]
+[SupportedOn(typeof(TestVolumeComponent0527))]
+[Obsolete]
+        public class TestVolumeComponent0422 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1196312587);
+        }
+        public class TestVolumeComponent0423 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(405846975);
+        }
+[SupportedOn(typeof(TestVolumeComponent0498))]
+[VolumeComponentMenu("fBUgINMRITQsOZUcUTAFCovgrBr_EsfDQPtZIoAPKubJ DlkKarZxcSzKLEHnPjqCwIwdNOmOoEmbixBKR/zAPfzCetVMPQsdPYH/ZKwMHAeUzOiQmf_MHdJdRncWkpZnFjqpefsUDCzWNfXImbJITEHMatcCkSZncUPKPvRAgYk")]
+        public class TestVolumeComponent0424 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(722620721);
+        }
+[SupportedOn(typeof(TestVolumeComponent0518))]
+        public class TestVolumeComponent0425 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(573066549);
+        }
+        public class TestVolumeComponent0426 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(790947869);
+        }
+[SupportedOn(typeof(TestVolumeComponent0529))]
+[HideInInspector]
+        public class TestVolumeComponent0427 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1869728992);
+        }
+[SupportedOn(typeof(TestVolumeComponent0487))]
+[Obsolete]
+[VolumeComponentMenu("HMgUJr_WTlaYuCFfLhBEkl_Kq")]
+        public class TestVolumeComponent0428 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(887652077);
+        }
+[SupportedOn(typeof(TestVolumeComponent0578))]
+        public class TestVolumeComponent0429 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1778474705);
+        }
+[SupportedOn(typeof(TestVolumeComponent0587))]
+[SupportedOn(typeof(TestVolumeComponent0566))]
+[Obsolete]
+        public class TestVolumeComponent0430 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1628896070);
+        }
+[SupportedOn(typeof(TestVolumeComponent0559))]
+[SupportedOn(typeof(TestVolumeComponent0558))]
+        public class TestVolumeComponent0431 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(478809302);
+        }
+[SupportedOn(typeof(TestVolumeComponent0663))]
+[SupportedOn(typeof(TestVolumeComponent0434))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu(" BpsdPOXpeQcjsUwboniSBfXCPnFWVrzjaKeGzMeELKR FKzvqGk ZOZYXOzxsdkrZKqtmjROXxJULSzdqUknJn_jwdchgtPSgWHlBQRtkYN spP RKmfR kEw")]
+        public class TestVolumeComponent0432 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(772446771);
+        }
+        public class TestVolumeComponent0433 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2142388903);
+        }
+[SupportedOn(typeof(TestVolumeComponent0524))]
+[HideInInspector]
+        public class TestVolumeComponent0434 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1667953246);
+        }
+[SupportedOn(typeof(TestVolumeComponent0490))]
+[SupportedOn(typeof(TestVolumeComponent0453))]
+        public class TestVolumeComponent0435 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1313662447);
+        }
+[SupportedOn(typeof(TestVolumeComponent0606))]
+        public class TestVolumeComponent0436 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1018848795);
+        }
+[SupportedOn(typeof(TestVolumeComponent0535))]
+        public class TestVolumeComponent0437 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1238457495);
+        }
+[SupportedOn(typeof(TestVolumeComponent0496))]
+        public class TestVolumeComponent0438 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1644375139);
+        }
+[SupportedOn(typeof(TestVolumeComponent0681))]
+[SupportedOn(typeof(TestVolumeComponent0680))]
+[VolumeComponentMenu("ZhelDtzSRlFSTdsGatJKD/sSJSkWRjT/w/ZQsduOznX/FWBlVYqUaSzxiAwtinznFhDrNMLnmvNpqlHfc eSF _OVIk DIXritgGJAcrupmIe XtPdFhFlXYXQPGexTxoAgrZvuGRScABjDdXWzvTWLIRMHdmvHdTpPEuGNbVGFfaCgYLrcvF/sxPWRYPjT")]
+        public class TestVolumeComponent0439 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(372291711);
+        }
+[SupportedOn(typeof(TestVolumeComponent0689))]
+[VolumeComponentMenu("NM_YRGZnkjZQuC_UadRETjHWBdLYVMqSBQNEitodVSqEwfk uvkxudNKiKiIuMupzxuQqADCTtojNhZ FbuKJOq")]
+        public class TestVolumeComponent0440 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(390426095);
+        }
+[SupportedOn(typeof(TestVolumeComponent0658))]
+[HideInInspector]
+        public class TestVolumeComponent0441 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(658040699);
+        }
+[SupportedOn(typeof(TestVolumeComponent0476))]
+[SupportedOn(typeof(TestVolumeComponent0539))]
+        public class TestVolumeComponent0442 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1829845847);
+        }
+[VolumeComponentMenu("bNnNEiKZdw/Lh_Ia/ZAujRdurZQuvgrNhmpRjmUNxipmSVtghz/PWcbN VhJQsIeKaWsGFpiWaK_ FCmdk DdztTlX/k/Jr_AzYeMcpc/wdPABbqlP wEcCZIwGiMsnJhRARxXbFdHvwbL/XO_AgMPIgYcbB")]
+        public class TestVolumeComponent0443 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(82531297);
+        }
+[VolumeComponentMenu("MmWFWoGz/DfalZnRQHSitHfiva/sQJSqbafaWzpaEXYBYzYaMivqAkGT sW_QzWBdRGcjJp_GJKTSF/q")]
+        public class TestVolumeComponent0444 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(22640237);
+        }
+[SupportedOn(typeof(TestVolumeComponent0594))]
+        public class TestVolumeComponent0445 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(667507281);
+        }
+[Obsolete]
+        public class TestVolumeComponent0446 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1504062913);
+        }
+[SupportedOn(typeof(TestVolumeComponent0589))]
+        public class TestVolumeComponent0447 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1917966205);
+        }
+[SupportedOn(typeof(TestVolumeComponent0486))]
+[VolumeComponentMenu("")]
+        public class TestVolumeComponent0448 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(459495229);
+        }
+[SupportedOn(typeof(TestVolumeComponent0502))]
+[SupportedOn(typeof(TestVolumeComponent0657))]
+[Obsolete]
+        public class TestVolumeComponent0449 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1583752698);
+        }
+[SupportedOn(typeof(TestVolumeComponent0554))]
+        public class TestVolumeComponent0450 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(61368374);
+        }
+[SupportedOn(typeof(TestVolumeComponent0547))]
+[HideInInspector]
+[VolumeComponentMenu("LUov_dqCXfLIonkCe/L NtanLSalPrJKiKNhkYcnsMkQBxPA_vH NnDQsUXjTGoETI_pmSoGsxoOFnsrNULjgrobofHdaCBKkMubaOmteOmlcjmjZOuAutRSF/TQspc/BAVCLEoxFOLvkEHrXWeEop_pLdXrmfohPfuG_bqpZMuCurqxTn_OzQBSLMs/iYBUXYutzxFCiYNOslqtXGafFfZQwvc")]
+        public class TestVolumeComponent0451 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1537918143);
+        }
+[SupportedOn(typeof(TestVolumeComponent0573))]
+[SupportedOn(typeof(TestVolumeComponent0704))]
+[HideInInspector]
+        public class TestVolumeComponent0452 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(39643635);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("xR mfqOiIFKPdajgQ_bwvHAHAgjVrZvB/RlBnsdD/JpkjBGJIHQersrcUHYNAgvabPpZEwYzdqlZrgEXGwWHbcKDOFOFGerHvP/sYotXOatTWT/LEsSuAiIcQc")]
+        public class TestVolumeComponent0453 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1091527731);
+        }
+[SupportedOn(typeof(TestVolumeComponent0583))]
+[SupportedOn(typeof(TestVolumeComponent0602))]
+        public class TestVolumeComponent0454 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2088311852);
+        }
+[SupportedOn(typeof(TestVolumeComponent0467))]
+[SupportedOn(typeof(TestVolumeComponent0650))]
+        public class TestVolumeComponent0455 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(724772776);
+        }
+[SupportedOn(typeof(TestVolumeComponent0659))]
+[SupportedOn(typeof(TestVolumeComponent0694))]
+        public class TestVolumeComponent0456 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1647942573);
+        }
+[SupportedOn(typeof(TestVolumeComponent0591))]
+[SupportedOn(typeof(TestVolumeComponent0662))]
+[HideInInspector]
+        public class TestVolumeComponent0457 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(995945657);
+        }
+[Obsolete]
+        public class TestVolumeComponent0458 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(703614612);
+        }
+[SupportedOn(typeof(TestVolumeComponent0558))]
+        public class TestVolumeComponent0459 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1522631416);
+        }
+[SupportedOn(typeof(TestVolumeComponent0567))]
+[SupportedOn(typeof(TestVolumeComponent0666))]
+        public class TestVolumeComponent0460 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1392984733);
+        }
+[SupportedOn(typeof(TestVolumeComponent0563))]
+[SupportedOn(typeof(TestVolumeComponent0570))]
+        public class TestVolumeComponent0461 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(742102941);
+        }
+[HideInInspector]
+[VolumeComponentMenu("oEZjRvRr_pVSPAZvNOwQkhoKe")]
+        public class TestVolumeComponent0462 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(343171949);
+        }
+[SupportedOn(typeof(TestVolumeComponent0612))]
+[SupportedOn(typeof(TestVolumeComponent0703))]
+        public class TestVolumeComponent0463 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(755185546);
+        }
+[SupportedOn(typeof(TestVolumeComponent0600))]
+[SupportedOn(typeof(TestVolumeComponent0487))]
+[HideInInspector]
+        public class TestVolumeComponent0464 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(35319238);
+        }
+        public class TestVolumeComponent0465 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1687011417);
+        }
+[SupportedOn(typeof(TestVolumeComponent0639))]
+[Obsolete]
+[VolumeComponentMenu("BIiCXYwv_GuOsKPvzWw")]
+        public class TestVolumeComponent0466 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1158530063);
+        }
+[SupportedOn(typeof(TestVolumeComponent0492))]
+[SupportedOn(typeof(TestVolumeComponent0687))]
+[HideInInspector]
+        public class TestVolumeComponent0467 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1547818819);
+        }
+[SupportedOn(typeof(TestVolumeComponent0629))]
+[HideInInspector]
+        public class TestVolumeComponent0468 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2088560215);
+        }
+[SupportedOn(typeof(TestVolumeComponent0655))]
+[SupportedOn(typeof(TestVolumeComponent0638))]
+        public class TestVolumeComponent0469 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1685164203);
+        }
+[SupportedOn(typeof(TestVolumeComponent0583))]
+        public class TestVolumeComponent0470 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1090585823);
+        }
+[SupportedOn(typeof(TestVolumeComponent0656))]
+        public class TestVolumeComponent0471 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(706077203);
+        }
+[SupportedOn(typeof(TestVolumeComponent0537))]
+[SupportedOn(typeof(TestVolumeComponent0684))]
+        public class TestVolumeComponent0472 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1425053900);
+        }
+[SupportedOn(typeof(TestVolumeComponent0549))]
+[SupportedOn(typeof(TestVolumeComponent0604))]
+[Obsolete]
+        public class TestVolumeComponent0473 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1906360200);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0474 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(188779439);
+        }
+        public class TestVolumeComponent0475 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1688985531);
+        }
+[SupportedOn(typeof(TestVolumeComponent0638))]
+        public class TestVolumeComponent0476 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(506084407);
+        }
+[SupportedOn(typeof(TestVolumeComponent0599))]
+[SupportedOn(typeof(TestVolumeComponent0710))]
+[HideInInspector]
+        public class TestVolumeComponent0477 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1665615619);
+        }
+[SupportedOn(typeof(TestVolumeComponent0528))]
+[HideInInspector]
+[VolumeComponentMenu("_KTYFjzOX/BIi")]
+        public class TestVolumeComponent0478 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1771416701);
+        }
+[SupportedOn(typeof(TestVolumeComponent0660))]
+[SupportedOn(typeof(TestVolumeComponent0559))]
+[VolumeComponentMenu("GLSDhFIRSRdNUejJpXKLpaxFYLWDIkUmjqCsjkbPpVY_fkdabmUkfTOXlJIJfRAqKLxw LlshktRC_ aCgYofXWiI_tBlXteKTxejHGLAq BjF qjZngGuAXGqvV RjiCVvzxetTxalBCetcCTEaYwEHCk/_SHlqbRWu/mKPODtuWzduWHxqQiAPj_hDQLYVvu")]
+        public class TestVolumeComponent0479 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1741603835);
+        }
+[SupportedOn(typeof(TestVolumeComponent0497))]
+[SupportedOn(typeof(TestVolumeComponent0516))]
+[HideInInspector]
+        public class TestVolumeComponent0480 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1362566703);
+        }
+[SupportedOn(typeof(TestVolumeComponent0570))]
+        public class TestVolumeComponent0481 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(128533347);
+        }
+[SupportedOn(typeof(TestVolumeComponent0707))]
+[VolumeComponentMenu("FEu/zGZxJtcjalepmlFxX kQiMzYmrFEaMstcCmxkKLIutNCXpe/sCqWzlwMebels/DtcrahexkxqGq NnLlsr_dqSLngI_hVSXKVWXUXIoM_EV")]
+        public class TestVolumeComponent0482 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1248604783);
+        }
+[HideInInspector]
+[VolumeComponentMenu("BSmhJlTYNfaSVMuCaYVWBhBncYotoKVnPhDjwWzC_jTxibsbDWHjgjRtu/N _fNCmnR R")]
+        public class TestVolumeComponent0483 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1696003085);
+        }
+        public class TestVolumeComponent0484 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1283940149);
+        }
+[SupportedOn(typeof(TestVolumeComponent0699))]
+        public class TestVolumeComponent0485 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(71581345);
+        }
+[SupportedOn(typeof(TestVolumeComponent0564))]
+[VolumeComponentMenu("xHbujcAoCifuMaCLtojXSgGepRhFYkIXUavctcfNdXjqrqOcbPIo cQDjeKcEcrcnNtihgKidDfilqxRhXCFWBpXxqxBbqQTdDfklHKNjwWofL/P/FlB _SolwEqrgYBvFWiMspXMPvFvZImng Jf_YuUmvqlkpwYglBOLxJfVOaOB/cQuCTEHWi")]
+        public class TestVolumeComponent0486 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2034942165);
+        }
+[SupportedOn(typeof(TestVolumeComponent0588))]
+[SupportedOn(typeof(TestVolumeComponent0615))]
+        public class TestVolumeComponent0487 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1438647698);
+        }
+[SupportedOn(typeof(TestVolumeComponent0704))]
+[SupportedOn(typeof(TestVolumeComponent0719))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("DSoCgMkteh_duYBAgpu")]
+        public class TestVolumeComponent0488 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(492118927);
+        }
+[SupportedOn(typeof(TestVolumeComponent0514))]
+[SupportedOn(typeof(TestVolumeComponent0709))]
+[HideInInspector]
+        public class TestVolumeComponent0489 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1526533827);
+        }
+[SupportedOn(typeof(TestVolumeComponent0651))]
+[SupportedOn(typeof(TestVolumeComponent0734))]
+        public class TestVolumeComponent0490 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1092415708);
+        }
+[SupportedOn(typeof(TestVolumeComponent0599))]
+        public class TestVolumeComponent0491 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1581146552);
+        }
+[SupportedOn(typeof(TestVolumeComponent0560))]
+[SupportedOn(typeof(TestVolumeComponent0727))]
+        public class TestVolumeComponent0492 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1343222748);
+        }
+        public class TestVolumeComponent0493 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(939047776);
+        }
+[SupportedOn(typeof(TestVolumeComponent0706))]
+        public class TestVolumeComponent0494 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1669037644);
+        }
+        public class TestVolumeComponent0495 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(410995963);
+        }
+[SupportedOn(typeof(TestVolumeComponent0513))]
+[SupportedOn(typeof(TestVolumeComponent0532))]
+[HideInInspector]
+        public class TestVolumeComponent0496 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(732706607);
+        }
+        public class TestVolumeComponent0497 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1789637947);
+        }
+        public class TestVolumeComponent0498 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(765153418);
+        }
+[SupportedOn(typeof(TestVolumeComponent0546))]
+[Obsolete]
+[VolumeComponentMenu("FSPrNMgncvcEkQPvolD/qpzfsWLnkxkxzYzraIzU_OTfHfJfeQFjN elmGaCznmtwdTjLMHdcpDQzrVrobFM_vzjkGTA_hcjPUBMwhNbPKanFEeUuhqWuOZMJWDrJWJMc/claKqAktiIsIqCDIcED")]
+        public class TestVolumeComponent0499 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1765157437);
+        }
+        public class TestVolumeComponent0500 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(720852037);
+        }
+        public class TestVolumeComponent0501 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1727879144);
+        }
+[SupportedOn(typeof(TestVolumeComponent0577))]
+[HideInInspector]
+        public class TestVolumeComponent0502 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(939020692);
+        }
+[SupportedOn(typeof(TestVolumeComponent0723))]
+[HideInInspector]
+        public class TestVolumeComponent0503 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(170934595);
+        }
+[Obsolete]
+        public class TestVolumeComponent0504 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1529594967);
+        }
+        public class TestVolumeComponent0505 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(536242414);
+        }
+[SupportedOn(typeof(TestVolumeComponent0593))]
+        public class TestVolumeComponent0506 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(574113362);
+        }
+[SupportedOn(typeof(TestVolumeComponent0698))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0507 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1619292153);
+        }
+[Obsolete]
+        public class TestVolumeComponent0508 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(242021481);
+        }
+[SupportedOn(typeof(TestVolumeComponent0731))]
+        public class TestVolumeComponent0509 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1601579557);
+        }
+[Obsolete]
+        public class TestVolumeComponent0510 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1985378696);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0511 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2146502063);
+        }
+[SupportedOn(typeof(TestVolumeComponent0601))]
+        public class TestVolumeComponent0512 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1857668835);
+        }
+[SupportedOn(typeof(TestVolumeComponent0738))]
+[SupportedOn(typeof(TestVolumeComponent0693))]
+[Obsolete]
+        public class TestVolumeComponent0513 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(894363708);
+        }
+[SupportedOn(typeof(TestVolumeComponent0558))]
+[Obsolete]
+[VolumeComponentMenu("EaIaMwWZImUsAeKBU_lVhmYebLb_OqCJvsjgfPnNEJSVbXng/eEgAeIzhejcUHvuhaEqAgvFlaUDSRMXOcGTxcxixadilivXnqAHKZCufkERpZlcdkbwtkCVC_ wIwrsIDW_KebanidmKLGLUDjRC_")]
+        public class TestVolumeComponent0514 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1460023591);
+        }
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0515 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(320555386);
+        }
+[SupportedOn(typeof(TestVolumeComponent0620))]
+        public class TestVolumeComponent0516 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(261603254);
+        }
+[HideInInspector]
+[VolumeComponentMenu(" oh_fzYVQNGFY_Ae/gIiKadB")]
+        public class TestVolumeComponent0517 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(276240245);
+        }
+[SupportedOn(typeof(TestVolumeComponent0683))]
+[Obsolete]
+        public class TestVolumeComponent0518 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(629380729);
+        }
+[SupportedOn(typeof(TestVolumeComponent0756))]
+[HideInInspector]
+        public class TestVolumeComponent0519 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(571151593);
+        }
+        public class TestVolumeComponent0520 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(254911908);
+        }
+[SupportedOn(typeof(TestVolumeComponent0652))]
+[Obsolete]
+        public class TestVolumeComponent0521 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(286913544);
+        }
+[SupportedOn(typeof(TestVolumeComponent0661))]
+[Obsolete]
+        public class TestVolumeComponent0522 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2080969516);
+        }
+[SupportedOn(typeof(TestVolumeComponent0670))]
+        public class TestVolumeComponent0523 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2018409328);
+        }
+[SupportedOn(typeof(TestVolumeComponent0615))]
+[SupportedOn(typeof(TestVolumeComponent0714))]
+[Obsolete]
+        public class TestVolumeComponent0524 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(869552533);
+        }
+[HideInInspector]
+[VolumeComponentMenu("buWFUzpovHlJQJMLbiQsYFvLtkIRtNUspLpPxLxHdJ/Xvcfctc/shqhehqrmUgOBWLtkGiIcfHSBtF k/idgCqYmfLvJMFWJSTSBdNWgjRKals/HSwhXdsnDQadHtuOF BvLhmYsINUeIXMXAm/zp_")]
+        public class TestVolumeComponent0525 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1409960871);
+        }
+[SupportedOn(typeof(TestVolumeComponent0535))]
+[SupportedOn(typeof(TestVolumeComponent0666))]
+        public class TestVolumeComponent0526 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1165680584);
+        }
+[VolumeComponentMenu("ROFlFdsjwGoGongnqOqjupiUilXMVS_xFUBfPtBORYkEzlVrJKBSPCNxmOgQDYJrRSaUeYkWa/L/BxabuMPMTSJYs/oCLMT")]
+        public class TestVolumeComponent0527 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(599052671);
+        }
+[SupportedOn(typeof(TestVolumeComponent0777))]
+[VolumeComponentMenu("BSitsvN/RpPhJOVMROFEmQXQeC_AgtcKXGBEPhoIgnqQFMgOkjq ZnwfefuWXAz/BC_rzvkWs/NKRpatsQPtPKa")]
+        public class TestVolumeComponent0528 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2109569775);
+        }
+[HideInInspector]
+[VolumeComponentMenu("ZdDMXYwSLbLCuCwtsScfkQNxJlkGonqAwUNCDluCaYz FYRKL/ZtZtehgEXMHQmlavirq")]
+        public class TestVolumeComponent0529 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(831112333);
+        }
+[SupportedOn(typeof(TestVolumeComponent0743))]
+        public class TestVolumeComponent0530 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2055892337);
+        }
+[SupportedOn(typeof(TestVolumeComponent0752))]
+        public class TestVolumeComponent0531 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1395661941);
+        }
+[VolumeComponentMenu("SzOVvHKFrZOVSZtJGilkhsKeOcWi LWufFvLtoWVOLQaYzUuOZlcMgEuQgYcdmY_vzfwGzjcIsjHGBYqpTxZbuOsQPUgtqfBtopirZpaIzjLh_UDfwxqlzUFQTSJvHEDxwENUFxcCwGiOgQa/mj_CNbihe sMRMgAXhPUNGNrH PWJUgheIuQkdm")]
+        public class TestVolumeComponent0532 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1077377365);
+        }
+        public class TestVolumeComponent0533 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(776801405);
+        }
+[SupportedOn(typeof(TestVolumeComponent0572))]
+[VolumeComponentMenu("")]
+        public class TestVolumeComponent0534 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1708278845);
+        }
+[SupportedOn(typeof(TestVolumeComponent0588))]
+[SupportedOn(typeof(TestVolumeComponent0743))]
+[Obsolete]
+        public class TestVolumeComponent0535 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1183152890);
+        }
+[SupportedOn(typeof(TestVolumeComponent0640))]
+        public class TestVolumeComponent0536 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2063707446);
+        }
+[SupportedOn(typeof(TestVolumeComponent0633))]
+[SupportedOn(typeof(TestVolumeComponent0568))]
+[HideInInspector]
+        public class TestVolumeComponent0537 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(874333570);
+        }
+        public class TestVolumeComponent0538 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1536112397);
+        }
+[SupportedOn(typeof(TestVolumeComponent0752))]
+        public class TestVolumeComponent0539 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1014686705);
+        }
+        public class TestVolumeComponent0540 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(651291041);
+        }
+        public class TestVolumeComponent0541 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1567203420);
+        }
+[SupportedOn(typeof(TestVolumeComponent0785))]
+[VolumeComponentMenu("HvXAXvFKPfTAabzM_bmOeYHOwvNSRpo/PIkQoON/w/BAZOiIRd_CaKDhklTnuxDYmK_peMznqdiEiS_jubVCLtN NluxDdDWDOanwtwbFlJpzxeIPKwvetwrznoCk/PbgCuvaGgQqEZWTQ_EirP B uGihwAgEeSoYLnFlJlVAJYwrLvHIaCPxwSe BxPlFAP")]
+        public class TestVolumeComponent0542 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1763752637);
+        }
+[SupportedOn(typeof(TestVolumeComponent0596))]
+[VolumeComponentMenu("_Akda chubZnedmbZKavsvebmYkrgfT LlzUVlwKNjRxNEDIDxsOwt_fTYidcWRpsYPWTpPAg/RfuIDvVlzvRpHvXrBhw/ZxehqQcGg HWajoUPdX/DQmdDWgvBtJbuhiG_E_EkUL/m")]
+        public class TestVolumeComponent0543 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(423636431);
+        }
+[SupportedOn(typeof(TestVolumeComponent0697))]
+[SupportedOn(typeof(TestVolumeComponent0636))]
+        public class TestVolumeComponent0544 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2129335984);
+        }
+[SupportedOn(typeof(TestVolumeComponent0661))]
+[VolumeComponentMenu("ngAcrNnofB/iEVxcSkxerwUZlHYLYRdP q _rVlPf_IoncCXfkGed_WBAkEVKNbeOHOw HvarDMmSJQXYgWzvXtRKaxiI_SaAorJAFAZQibXCq")]
+        public class TestVolumeComponent0545 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(830768399);
+        }
+[VolumeComponentMenu("lzrwfwEXfBMBbcMmbZfBnmtDrihajRWDdHSVIiOzjktovFWTpJER ZbujzEgKmYTfNdNbN ejDKX")]
+        public class TestVolumeComponent0546 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1755551633);
+        }
+[SupportedOn(typeof(TestVolumeComponent0576))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0547 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1571337432);
+        }
+[SupportedOn(typeof(TestVolumeComponent0591))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0548 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(743287679);
+        }
+        public class TestVolumeComponent0549 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(443589035);
+        }
+[SupportedOn(typeof(TestVolumeComponent0680))]
+[SupportedOn(typeof(TestVolumeComponent0679))]
+        public class TestVolumeComponent0550 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1006740199);
+        }
+[SupportedOn(typeof(TestVolumeComponent0688))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0551 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(649215966);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0552 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(324640613);
+        }
+[SupportedOn(typeof(TestVolumeComponent0686))]
+        public class TestVolumeComponent0553 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1798229865);
+        }
+[SupportedOn(typeof(TestVolumeComponent0759))]
+[SupportedOn(typeof(TestVolumeComponent0610))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0554 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2083872313);
+        }
+[SupportedOn(typeof(TestVolumeComponent0681))]
+[SupportedOn(typeof(TestVolumeComponent0640))]
+[VolumeComponentMenu("aMgQstkIu/oQTYgrZfHIBlVOXOeGitkIVWcCZ/_jsjkxFjwloSVdJCaMBnNhTjBloCZSZ/cAaAXtiSgQFCLlNlaEFCcMZlNxoUmpcAHYoWRtiYuGV/DpV/aUDYsCNYcCgQqbTWqMHlova/k NWupalefgQJUwSmQmWLbstVjRQ_WidPjcfwIBfTSwGLlkAJjRIsKF/BnXbBhJORUk/cQgpZxJxoGeUZQiQVSmKPIoQo")]
+        public class TestVolumeComponent0555 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1609336527);
+        }
+[SupportedOn(typeof(TestVolumeComponent0709))]
+[SupportedOn(typeof(TestVolumeComponent0648))]
+        public class TestVolumeComponent0556 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1462259632);
+        }
+[SupportedOn(typeof(TestVolumeComponent0673))]
+[SupportedOn(typeof(TestVolumeComponent0712))]
+[Obsolete]
+        public class TestVolumeComponent0557 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1652546708);
+        }
+[SupportedOn(typeof(TestVolumeComponent0657))]
+        public class TestVolumeComponent0558 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(818299128);
+        }
+[Obsolete]
+        public class TestVolumeComponent0559 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(337565252);
+        }
+[SupportedOn(typeof(TestVolumeComponent0620))]
+[SupportedOn(typeof(TestVolumeComponent0675))]
+[Obsolete]
+        public class TestVolumeComponent0560 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(97510240);
+        }
+[SupportedOn(typeof(TestVolumeComponent0620))]
+[Obsolete]
+[VolumeComponentMenu("FdRSodsCVKVCoWuIwrL/NjutB")]
+        public class TestVolumeComponent0561 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(944988525);
+        }
+        public class TestVolumeComponent0562 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(861563477);
+        }
+[SupportedOn(typeof(TestVolumeComponent0585))]
+[Obsolete]
+        public class TestVolumeComponent0563 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1188282561);
+        }
+[SupportedOn(typeof(TestVolumeComponent0706))]
+        public class TestVolumeComponent0564 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(29837949);
+        }
+        public class TestVolumeComponent0565 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1609489920);
+        }
+[SupportedOn(typeof(TestVolumeComponent0689))]
+[SupportedOn(typeof(TestVolumeComponent0596))]
+        public class TestVolumeComponent0566 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1525416005);
+        }
+[SupportedOn(typeof(TestVolumeComponent0813))]
+        public class TestVolumeComponent0567 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1111815089);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0568 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1881664916);
+        }
+[Obsolete]
+        public class TestVolumeComponent0569 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(890987843);
+        }
+[SupportedOn(typeof(TestVolumeComponent0731))]
+[HideInInspector]
+        public class TestVolumeComponent0570 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(105185367);
+        }
+[SupportedOn(typeof(TestVolumeComponent0757))]
+[SupportedOn(typeof(TestVolumeComponent0740))]
+        public class TestVolumeComponent0571 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(962600619);
+        }
+[SupportedOn(typeof(TestVolumeComponent0685))]
+        public class TestVolumeComponent0572 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(509043423);
+        }
+[SupportedOn(typeof(TestVolumeComponent0758))]
+        public class TestVolumeComponent0573 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(479907859);
+        }
+[SupportedOn(typeof(TestVolumeComponent0639))]
+[SupportedOn(typeof(TestVolumeComponent0786))]
+        public class TestVolumeComponent0574 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1730994892);
+        }
+[SupportedOn(typeof(TestVolumeComponent0651))]
+[SupportedOn(typeof(TestVolumeComponent0706))]
+[Obsolete]
+        public class TestVolumeComponent0575 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1268923784);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0576 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(84031919);
+        }
+        public class TestVolumeComponent0577 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(977709499);
+        }
+[SupportedOn(typeof(TestVolumeComponent0740))]
+        public class TestVolumeComponent0578 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(714524215);
+        }
+[SupportedOn(typeof(TestVolumeComponent0701))]
+[HideInInspector]
+[VolumeComponentMenu("NxXGiScAV/BSJGedqj_/T/LGFIudwnHbLUavRfeKREwhNQBrRKupzO_UDQZbVMFAcULUNQ_KoCHAgfXOXlgneMivk cUNhFbTbalwGcxBlmpcWHhTINCHODtgOoUghw/zbujk/VUcvJUXO_S_jgSR")]
+        public class TestVolumeComponent0579 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(320091325);
+        }
+[SupportedOn(typeof(TestVolumeComponent0633))]
+[VolumeComponentMenu("ZEqhR/JOwU_diScKTjXrohPYXhe/VpgbwGzSsrmKVSVtmvelHSPxJSiQTE_l_xTWLlTlcrXKZjsUPWwnotDbJQi N oMcMPQutsMoSPSwjolwlVCavDWLUkjLhFbDIJ/qjRSXYVODxL")]
+        public class TestVolumeComponent0580 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(572229583);
+        }
+[SupportedOn(typeof(TestVolumeComponent0734))]
+[SupportedOn(typeof(TestVolumeComponent0673))]
+        public class TestVolumeComponent0581 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(426894512);
+        }
+[SupportedOn(typeof(TestVolumeComponent0698))]
+[SupportedOn(typeof(TestVolumeComponent0737))]
+[Obsolete]
+        public class TestVolumeComponent0582 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(483395988);
+        }
+[SupportedOn(typeof(TestVolumeComponent0682))]
+        public class TestVolumeComponent0583 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1498369528);
+        }
+[SupportedOn(typeof(TestVolumeComponent0691))]
+[HideInInspector]
+        public class TestVolumeComponent0584 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1981764420);
+        }
+[SupportedOn(typeof(TestVolumeComponent0645))]
+[SupportedOn(typeof(TestVolumeComponent0700))]
+[Obsolete]
+        public class TestVolumeComponent0585 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(611456096);
+        }
+[VolumeComponentMenu("lqpT/LvzGNYzWm")]
+        public class TestVolumeComponent0586 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(72372335);
+        }
+[SupportedOn(typeof(TestVolumeComponent0804))]
+[HideInInspector]
+        public class TestVolumeComponent0587 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(508220411);
+        }
+        public class TestVolumeComponent0588 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(662066890);
+        }
+[SupportedOn(typeof(TestVolumeComponent0764))]
+        public class TestVolumeComponent0589 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(978496078);
+        }
+[SupportedOn(typeof(TestVolumeComponent0613))]
+[HideInInspector]
+        public class TestVolumeComponent0590 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(424340678);
+        }
+[SupportedOn(typeof(TestVolumeComponent0719))]
+[SupportedOn(typeof(TestVolumeComponent0718))]
+        public class TestVolumeComponent0591 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(670997590);
+        }
+[SupportedOn(typeof(TestVolumeComponent0823))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("zpeSiENMXEPSNx_INda")]
+        public class TestVolumeComponent0592 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1250447119);
+        }
+[VolumeComponentMenu("GFxDMHjFlTvqvepqSJ/zAkGeYmfiIzEZjDfstwjF oCBIufmbZxVfRvNEk kfmtmlzIBCwAk/XGk")]
+        public class TestVolumeComponent0593 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2012389777);
+        }
+[SupportedOn(typeof(TestVolumeComponent0623))]
+[SupportedOn(typeof(TestVolumeComponent0602))]
+[HideInInspector]
+        public class TestVolumeComponent0594 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1878683285);
+        }
+        public class TestVolumeComponent0595 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(149063229);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0596 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(914105536);
+        }
+        public class TestVolumeComponent0597 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(451247335);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0598 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1324272094);
+        }
+[SupportedOn(typeof(TestVolumeComponent0654))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0599 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(784763237);
+        }
+        public class TestVolumeComponent0600 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2050027309);
+        }
+[SupportedOn(typeof(TestVolumeComponent0735))]
+[SupportedOn(typeof(TestVolumeComponent0806))]
+[HideInInspector]
+        public class TestVolumeComponent0601 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(795728953);
+        }
+[Obsolete]
+        public class TestVolumeComponent0602 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1395831828);
+        }
+[SupportedOn(typeof(TestVolumeComponent0702))]
+[SupportedOn(typeof(TestVolumeComponent0689))]
+        public class TestVolumeComponent0603 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1799770465);
+        }
+[SupportedOn(typeof(TestVolumeComponent0810))]
+[SupportedOn(typeof(TestVolumeComponent0641))]
+        public class TestVolumeComponent0604 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(741893433);
+        }
+[SupportedOn(typeof(TestVolumeComponent0714))]
+        public class TestVolumeComponent0605 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(40016157);
+        }
+[HideInInspector]
+[VolumeComponentMenu("TEXKsfZpLlshFbZxVITOenLWq")]
+        public class TestVolumeComponent0606 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1268764909);
+        }
+[SupportedOn(typeof(TestVolumeComponent0756))]
+        public class TestVolumeComponent0607 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1128452305);
+        }
+[Obsolete]
+        public class TestVolumeComponent0608 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(118899265);
+        }
+[SupportedOn(typeof(TestVolumeComponent0751))]
+[SupportedOn(typeof(TestVolumeComponent0710))]
+        public class TestVolumeComponent0609 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1982904793);
+        }
+[SupportedOn(typeof(TestVolumeComponent0783))]
+[SupportedOn(typeof(TestVolumeComponent0826))]
+[HideInInspector]
+[VolumeComponentMenu("_GcQiMmAJ/TdqfuWXIs")]
+        public class TestVolumeComponent0610 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(468230543);
+        }
+[SupportedOn(typeof(TestVolumeComponent0636))]
+[Obsolete]
+        public class TestVolumeComponent0611 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(536267971);
+        }
+[SupportedOn(typeof(TestVolumeComponent0773))]
+[HideInInspector]
+        public class TestVolumeComponent0612 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(510961111);
+        }
+[SupportedOn(typeof(TestVolumeComponent0799))]
+[SupportedOn(typeof(TestVolumeComponent0782))]
+        public class TestVolumeComponent0613 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(251128363);
+        }
+[SupportedOn(typeof(TestVolumeComponent0727))]
+        public class TestVolumeComponent0614 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(52847199);
+        }
+[SupportedOn(typeof(TestVolumeComponent0800))]
+        public class TestVolumeComponent0615 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(216400787);
+        }
+        public class TestVolumeComponent0616 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(798773959);
+        }
+[SupportedOn(typeof(TestVolumeComponent0771))]
+        public class TestVolumeComponent0617 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1183916691);
+        }
+[SupportedOn(typeof(TestVolumeComponent0700))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("Wa/mCXfXUi/kCe kYoGutq/aUBIzhuSRAqnLIifBtTIFSTYPA_twr_UTUXYNtDEujXEXWuxHbPSkUXtmMFGoWVbgGo cWBjDIsMqAohTIeKuxkpBhqGoIRrZnV sxzYcKafuUelXCV")]
+        public class TestVolumeComponent0618 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(892553379);
+        }
+[SupportedOn(typeof(TestVolumeComponent0716))]
+[SupportedOn(typeof(TestVolumeComponent0671))]
+        public class TestVolumeComponent0619 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1512981372);
+        }
+[SupportedOn(typeof(TestVolumeComponent0792))]
+[HideInInspector]
+        public class TestVolumeComponent0620 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1568323339);
+        }
+        public class TestVolumeComponent0621 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1172134591);
+        }
+[SupportedOn(typeof(TestVolumeComponent0696))]
+[SupportedOn(typeof(TestVolumeComponent0743))]
+[Obsolete]
+        public class TestVolumeComponent0622 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(157335667);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("/wIT/DAZ qYF/XnmYBpoCaEcOXjwAivRMDImpROwUudZAFnPKP/sKZfspcG_hHYu qjNhFMTYoU_luIaUiIzYVvaEHSLGBSHUzWkdJtHvVEDIRfTbeSehexBlR")]
+        public class TestVolumeComponent0623 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1979883187);
+        }
+[SupportedOn(typeof(TestVolumeComponent0753))]
+        public class TestVolumeComponent0624 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(281917927);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0625 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(604360414);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0626 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1386673765);
+        }
+[SupportedOn(typeof(TestVolumeComponent0760))]
+        public class TestVolumeComponent0627 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1061153385);
+        }
+[SupportedOn(typeof(TestVolumeComponent0833))]
+[HideInInspector]
+        public class TestVolumeComponent0628 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1490149689);
+        }
+[SupportedOn(typeof(TestVolumeComponent0755))]
+[SupportedOn(typeof(TestVolumeComponent0714))]
+[VolumeComponentMenu("eQZf_ _hDvu HUXtZMqWsMsCsAiva/ungdqjmGLdoEHWwlmlwdDpo/ZfmfBIJ P oKLOVKH/ilzlgvXYmSqEaOH/PUwrVSDhTAJhzxRIsWDfZ BYkberTxzYcCHjo/wKubzvkbRGPpiAaEzYuvm BKTYwIBfZOVUg/LjmAZCZhijkGsna ktgYLQD/kWH TduQDOLEoGHvmYXAzpZ ipL/FSaAXhwjkfFhwAgKDj_Uk")]
+        public class TestVolumeComponent0629 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1526243791);
+        }
+[SupportedOn(typeof(TestVolumeComponent0783))]
+        public class TestVolumeComponent0630 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(478025219);
+        }
+[SupportedOn(typeof(TestVolumeComponent0664))]
+        public class TestVolumeComponent0631 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1579508535);
+        }
+[SupportedOn(typeof(TestVolumeComponent0673))]
+[SupportedOn(typeof(TestVolumeComponent0868))]
+        public class TestVolumeComponent0632 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(978451576);
+        }
+[SupportedOn(typeof(TestVolumeComponent0829))]
+[Obsolete]
+        public class TestVolumeComponent0633 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(373240132);
+        }
+[SupportedOn(typeof(TestVolumeComponent0694))]
+[SupportedOn(typeof(TestVolumeComponent0749))]
+[Obsolete]
+        public class TestVolumeComponent0634 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(660577888);
+        }
+[VolumeComponentMenu("ruUmCiKVlNQJnz")]
+        public class TestVolumeComponent0635 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1972361839);
+        }
+[HideInInspector]
+[VolumeComponentMenu("XWZYu iKHxNOJduIcGgWcdJYod_lDWzIupgnBYkhwfZWZORUZhR VjcWXtipHCe/NMHhR")]
+        public class TestVolumeComponent0636 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(144006157);
+        }
+[SupportedOn(typeof(TestVolumeComponent0850))]
+[SupportedOn(typeof(TestVolumeComponent0813))]
+        public class TestVolumeComponent0637 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(191333738);
+        }
+        public class TestVolumeComponent0638 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(360494069);
+        }
+[SupportedOn(typeof(TestVolumeComponent0804))]
+[Obsolete]
+        public class TestVolumeComponent0639 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(355448569);
+        }
+[SupportedOn(typeof(TestVolumeComponent0877))]
+[SupportedOn(typeof(TestVolumeComponent0792))]
+        public class TestVolumeComponent0640 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1451976430);
+        }
+[SupportedOn(typeof(TestVolumeComponent0785))]
+[SupportedOn(typeof(TestVolumeComponent0784))]
+        public class TestVolumeComponent0641 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1854290238);
+        }
+[SupportedOn(typeof(TestVolumeComponent0889))]
+[HideInInspector]
+[VolumeComponentMenu("nJhepmIcYHhPxiAgIB zKRlkrPCglBhwnVdXlzCVfwWRAgSPdHfPfoMulZjFpeIeQBrkGuITtcvHvk DQoWVC_IVUclRIZMulkdztJhzIDEPETSBvBEqnkxHMTG_jiUqWgCkUe/_QJ")]
+        public class TestVolumeComponent0642 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1758767139);
+        }
+[SupportedOn(typeof(TestVolumeComponent0740))]
+[SupportedOn(typeof(TestVolumeComponent0695))]
+        public class TestVolumeComponent0643 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1914404092);
+        }
+[Obsolete]
+        public class TestVolumeComponent0644 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1425953419);
+        }
+[SupportedOn(typeof(TestVolumeComponent0694))]
+        public class TestVolumeComponent0645 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1644189375);
+        }
+[SupportedOn(typeof(TestVolumeComponent0767))]
+[Obsolete]
+        public class TestVolumeComponent0646 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1429687283);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("OHxVnstNrJEilzSVbRAebBERIwvVQaGBnaledBANGiYzfHlm TEcMz uELxuQBdzhsxsEoILvFdgYkjZfujolkdP/FtujmWs VOaMTCipw/mdgfPpiATWqlTYw")]
+        public class TestVolumeComponent0647 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2037679667);
+        }
+[SupportedOn(typeof(TestVolumeComponent0777))]
+        public class TestVolumeComponent0648 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1036916071);
+        }
+[SupportedOn(typeof(TestVolumeComponent0786))]
+[SupportedOn(typeof(TestVolumeComponent0661))]
+        public class TestVolumeComponent0649 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1851165192);
+        }
+[SupportedOn(typeof(TestVolumeComponent0878))]
+        public class TestVolumeComponent0650 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1003758548);
+        }
+        public class TestVolumeComponent0651 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(769069827);
+        }
+[SupportedOn(typeof(TestVolumeComponent0685))]
+[SupportedOn(typeof(TestVolumeComponent0768))]
+[VolumeComponentMenu("OeSTbPMzvXnNpBORpwEXxqb_SLYg XlohNCLUVbkGTxangxHMLWkGu/mKiKejcjzrTWuxXEc/ghVIFbJOXpLtNbmOmlkfwUunkdBQoQTGqxFMD")]
+        public class TestVolumeComponent0652 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1211893263);
+        }
+[SupportedOn(typeof(TestVolumeComponent0678))]
+[Obsolete]
+        public class TestVolumeComponent0653 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1996605763);
+        }
+[SupportedOn(typeof(TestVolumeComponent0815))]
+[HideInInspector]
+        public class TestVolumeComponent0654 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1834249303);
+        }
+[SupportedOn(typeof(TestVolumeComponent0841))]
+        public class TestVolumeComponent0655 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(81650211);
+        }
+[SupportedOn(typeof(TestVolumeComponent0770))]
+[SupportedOn(typeof(TestVolumeComponent0769))]
+        public class TestVolumeComponent0656 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(481883871);
+        }
+[SupportedOn(typeof(TestVolumeComponent0842))]
+[SupportedOn(typeof(TestVolumeComponent0845))]
+        public class TestVolumeComponent0657 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(791781344);
+        }
+[SupportedOn(typeof(TestVolumeComponent0870))]
+        public class TestVolumeComponent0658 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(299728588);
+        }
+[SupportedOn(typeof(TestVolumeComponent0735))]
+[SupportedOn(typeof(TestVolumeComponent0790))]
+[Obsolete]
+        public class TestVolumeComponent0659 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1936327048);
+        }
+[SupportedOn(typeof(TestVolumeComponent0799))]
+[SupportedOn(typeof(TestVolumeComponent0706))]
+[HideInInspector]
+        public class TestVolumeComponent0660 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1366110380);
+        }
+[SupportedOn(typeof(TestVolumeComponent0808))]
+        public class TestVolumeComponent0661 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1198490864);
+        }
+[Obsolete]
+        public class TestVolumeComponent0662 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(978882620);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0663 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(73424131);
+        }
+[SupportedOn(typeof(TestVolumeComponent0714))]
+[SupportedOn(typeof(TestVolumeComponent0841))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("FbTI_pFlBbZWe")]
+        public class TestVolumeComponent0664 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1954569853);
+        }
+[SupportedOn(typeof(TestVolumeComponent0846))]
+[SupportedOn(typeof(TestVolumeComponent0745))]
+[VolumeComponentMenu("jwxP JlgnmjqWgfBxaEJEFpsjTGFvinoEgQmIcUVGavXUefBrX/oMz XtPILUk/cYuEHrPARSLS_WBKcGqjPlPMuEopoxXpqQeMBnFtoYNbNtLMTrm oCmQztNSHvzhaKLIqGwjPda/HpNEzbwfHSeIuhgAzhzrJAepkhzjstwAstcEupHEJlTQ_nTUkhc/wdN")]
+        public class TestVolumeComponent0665 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(463058427);
+        }
+[SupportedOn(typeof(TestVolumeComponent0683))]
+[Obsolete]
+        public class TestVolumeComponent0666 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2062512175);
+        }
+[SupportedOn(typeof(TestVolumeComponent0756))]
+        public class TestVolumeComponent0667 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2105845091);
+        }
+[SupportedOn(typeof(TestVolumeComponent0893))]
+[VolumeComponentMenu("NQRxqhwlo/uSVIoQkxiMzt_tDlcfNScvcGctT ZpLvqMV iSZtRKqncxuIsdinP/sKNOLvwIeSZjkORGBIHnXvJlDvVYTfgOgjRQVQXjVdu/zKc")]
+        public class TestVolumeComponent0668 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1845986415);
+        }
+[SupportedOn(typeof(TestVolumeComponent0886))]
+[SupportedOn(typeof(TestVolumeComponent0697))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0669 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1129205755);
+        }
+[SupportedOn(typeof(TestVolumeComponent0704))]
+[SupportedOn(typeof(TestVolumeComponent0767))]
+        public class TestVolumeComponent0670 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(606632407);
+        }
+[VolumeComponentMenu("KDImIXbNARWVKFtqYVKXSzOHvHbNUTUNvorc/XMFbu zjkCcKBrkjZSTCDIB uQLIRngCFOFSa cGXQkGeE_x_tgp_EJGX BvHtJxXneIVQsnZAJMXtPviEwCm/a/_fwGebalsO_IXWLhX/w/qImxuYuAZrg")]
+        public class TestVolumeComponent0671 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(237119073);
+        }
+[VolumeComponentMenu("tTbDAzlq kbHrHGeIgMajDlHfHAD/RvaUTIR/XIRGgrDMZjFnqhopHY_YeMFAcdcC_nDtJ/gSsOelF k")]
+        public class TestVolumeComponent0672 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1441330413);
+        }
+[SupportedOn(typeof(TestVolumeComponent0822))]
+        public class TestVolumeComponent0673 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(559940817);
+        }
+[SupportedOn(typeof(TestVolumeComponent0831))]
+[HideInInspector]
+        public class TestVolumeComponent0674 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(182087233);
+        }
+[SupportedOn(typeof(TestVolumeComponent0817))]
+[SupportedOn(typeof(TestVolumeComponent0776))]
+        public class TestVolumeComponent0675 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(74517977);
+        }
+[VolumeComponentMenu("")]
+        public class TestVolumeComponent0676 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1242935741);
+        }
+[SupportedOn(typeof(TestVolumeComponent0730))]
+[SupportedOn(typeof(TestVolumeComponent0885))]
+[Obsolete]
+        public class TestVolumeComponent0677 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(269721210);
+        }
+[SupportedOn(typeof(TestVolumeComponent0782))]
+        public class TestVolumeComponent0678 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(608669878);
+        }
+[SupportedOn(typeof(TestVolumeComponent0775))]
+[HideInInspector]
+[VolumeComponentMenu("NALtzKV ipTQwfDML/cMcONSFjJdXWwnPWVvg ajoQLYFUVvTCoGRpuOoUB snFAmbojeGNtRpFIkOw HYZpkUwjZ NlkxodanVCVILjXt_GZn_dRKHbRh_KzlZbXrkfRQijwINnR JYLONrNEzILAoKmdPhTrVWmIJKoYJnorq/_tkdDtenNGglNlZCFOqbzUFhZSFv_GBnwQJMq/XSPCoMJWR")]
+        public class TestVolumeComponent0679 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1326026559);
+        }
+[SupportedOn(typeof(TestVolumeComponent0801))]
+[Obsolete]
+        public class TestVolumeComponent0680 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1685681267);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("YoGZCFIiYoUREPGLGilzYHfunk cYLrktgtRIsrBQqrJrFSsf_KVQujPODSVdwOsl_QRCTtcILpRADAcbaxP/NCeUgfVtzjoYBILruYVERvVCDniGuraxNGTps")]
+        public class TestVolumeComponent0681 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(207307443);
+        }
+        public class TestVolumeComponent0682 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1634210087);
+        }
+[Obsolete]
+        public class TestVolumeComponent0683 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(769405662);
+        }
+[SupportedOn(typeof(TestVolumeComponent0739))]
+[SupportedOn(typeof(TestVolumeComponent0702))]
+        public class TestVolumeComponent0684 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1706252399);
+        }
+[SupportedOn(typeof(TestVolumeComponent0855))]
+        public class TestVolumeComponent0685 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2017020059);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0686 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1261877054);
+        }
+[VolumeComponentMenu("DGJlVIRbevFCaWoGwMPnJIebklotqfiCmGRGVhsQ_hknslRMzxTnLpiGRGJWqKodc TtkIRhNjsbTGcKuOedejNOFKwKXbwtiImtJ/wUaAqlTSLrRjTETOZCZCJOLQ_ScMRtDCaxepkQubRpN/ZGkfBjzYzlFAmrajVhRAVMPtzENtspVnXQJjVnuYspsCmONj_UBMe XQq/qpJpZnq VIw/uxmbRAstRSXKRKeQLOJ")]
+        public class TestVolumeComponent0687 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1557304783);
+        }
+        public class TestVolumeComponent0688 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(715738395);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0689 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1352759230);
+        }
+[SupportedOn(typeof(TestVolumeComponent0738))]
+[SupportedOn(typeof(TestVolumeComponent0801))]
+[HideInInspector]
+        public class TestVolumeComponent0690 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2086613930);
+        }
+        public class TestVolumeComponent0691 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(638597813);
+        }
+[SupportedOn(typeof(TestVolumeComponent0729))]
+[SupportedOn(typeof(TestVolumeComponent0884))]
+        public class TestVolumeComponent0692 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1707665714);
+        }
+[SupportedOn(typeof(TestVolumeComponent0717))]
+        public class TestVolumeComponent0693 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(460224302);
+        }
+[SupportedOn(typeof(TestVolumeComponent0710))]
+[SupportedOn(typeof(TestVolumeComponent0709))]
+[VolumeComponentMenu("B zUHrzQDW_MqAZUHOqUodipzOaWN/DxHpPYDfXUztZIZAThRSipe")]
+        public class TestVolumeComponent0694 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1990630717);
+        }
+[SupportedOn(typeof(TestVolumeComponent0748))]
+[VolumeComponentMenu("ZOkjNYoMzIzYm BdNQoQRGcdZhzlZroOXhHvTIoEzEzlBGJnFfDjRrRhcvJANdHWPpeWJKLMmKLQJhm Fh_tDSuMifXAsfeCJhLfzWP/g/_bctw J/sMipcUPMeYBjwOeEsnZjexTMR")]
+        public class TestVolumeComponent0695 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(823797839);
+        }
+        public class TestVolumeComponent0696 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(660451739);
+        }
+[SupportedOn(typeof(TestVolumeComponent0795))]
+[SupportedOn(typeof(TestVolumeComponent0730))]
+        public class TestVolumeComponent0697 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(703015351);
+        }
+        public class TestVolumeComponent0698 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1967300579);
+        }
+        public class TestVolumeComponent0699 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(533224082);
+        }
+[SupportedOn(typeof(TestVolumeComponent0763))]
+        public class TestVolumeComponent0700 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(273274422);
+        }
+        public class TestVolumeComponent0701 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(721184686);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("ZtmOHjzraEoULSmfVIilN Tn_")]
+        public class TestVolumeComponent0702 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1975996141);
+        }
+        public class TestVolumeComponent0703 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(631612885);
+        }
+[SupportedOn(typeof(TestVolumeComponent0726))]
+[SupportedOn(typeof(TestVolumeComponent0861))]
+[HideInInspector]
+        public class TestVolumeComponent0704 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2944065);
+        }
+[SupportedOn(typeof(TestVolumeComponent0847))]
+[SupportedOn(typeof(TestVolumeComponent0806))]
+        public class TestVolumeComponent0705 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1878243289);
+        }
+[SupportedOn(typeof(TestVolumeComponent0879))]
+[SupportedOn(typeof(TestVolumeComponent0922))]
+[HideInInspector]
+[VolumeComponentMenu("wGFYFpDUTd_/XYVWLls")]
+        public class TestVolumeComponent0706 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(152608655);
+        }
+[SupportedOn(typeof(TestVolumeComponent0732))]
+[Obsolete]
+        public class TestVolumeComponent0707 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1454070467);
+        }
+[SupportedOn(typeof(TestVolumeComponent0869))]
+[HideInInspector]
+        public class TestVolumeComponent0708 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1000812503);
+        }
+        public class TestVolumeComponent0709 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1013105262);
+        }
+[SupportedOn(typeof(TestVolumeComponent0797))]
+[SupportedOn(typeof(TestVolumeComponent0824))]
+        public class TestVolumeComponent0710 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2028100383);
+        }
+[SupportedOn(typeof(TestVolumeComponent0721))]
+        public class TestVolumeComponent0711 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(385882187);
+        }
+        public class TestVolumeComponent0712 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1316524346);
+        }
+[SupportedOn(typeof(TestVolumeComponent0856))]
+[SupportedOn(typeof(TestVolumeComponent0867))]
+        public class TestVolumeComponent0713 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1086196883);
+        }
+[SupportedOn(typeof(TestVolumeComponent0796))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("Mg/PGTbJbHlXtFlcvB zOBSuOuGidPYi glBtgdJ/PUohHxDbilDMLxBpFCirkEFpDAHGeSTQPAFbPEeOcrkdNCuAJYBjDrkvVbRvR/w/BrTYkQVpLtNSzjDO_GmnsUFvDEi/TCVlJ")]
+        public class TestVolumeComponent0714 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(397784739);
+        }
+[SupportedOn(typeof(TestVolumeComponent0812))]
+[SupportedOn(typeof(TestVolumeComponent0767))]
+        public class TestVolumeComponent0715 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1908084092);
+        }
+[Obsolete]
+        public class TestVolumeComponent0716 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(326198539);
+        }
+[SupportedOn(typeof(TestVolumeComponent0766))]
+[SupportedOn(typeof(TestVolumeComponent0849))]
+        public class TestVolumeComponent0717 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1896424740);
+        }
+[Obsolete]
+        public class TestVolumeComponent0718 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2027789939);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("QNvXAeOZOzlZEFtJMcdN uEZINQXQJ/opPQeITKu/F sAVYahBhFCBYqjJQXjwrTUZC_/NWiQmfgvqfHxolZGHKsnT/gb_xqYqlaUgIVWBpzETSPWmEXKkMBSm")]
+        public class TestVolumeComponent0719 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1489104051);
+        }
+[SupportedOn(typeof(TestVolumeComponent0849))]
+[SupportedOn(typeof(TestVolumeComponent0868))]
+        public class TestVolumeComponent0720 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1946981036);
+        }
+[SupportedOn(typeof(TestVolumeComponent0733))]
+[SupportedOn(typeof(TestVolumeComponent0916))]
+        public class TestVolumeComponent0721 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1986650152);
+        }
+[SupportedOn(typeof(TestVolumeComponent0925))]
+        public class TestVolumeComponent0722 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1703042636);
+        }
+[SupportedOn(typeof(TestVolumeComponent0934))]
+[SupportedOn(typeof(TestVolumeComponent0857))]
+[Obsolete]
+        public class TestVolumeComponent0723 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1089063737);
+        }
+[Obsolete]
+        public class TestVolumeComponent0724 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(850360084);
+        }
+[SupportedOn(typeof(TestVolumeComponent0824))]
+[SupportedOn(typeof(TestVolumeComponent0811))]
+        public class TestVolumeComponent0725 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1342115937);
+        }
+[SupportedOn(typeof(TestVolumeComponent0932))]
+        public class TestVolumeComponent0726 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1132399901);
+        }
+[SupportedOn(typeof(TestVolumeComponent0829))]
+[SupportedOn(typeof(TestVolumeComponent0836))]
+        public class TestVolumeComponent0727 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1967037469);
+        }
+[SupportedOn(typeof(TestVolumeComponent0973))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("Zfa kjRtRSqYNIXhqbqWZ/BnL")]
+        public class TestVolumeComponent0728 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(856749037);
+        }
+[SupportedOn(typeof(TestVolumeComponent0878))]
+[SupportedOn(typeof(TestVolumeComponent0969))]
+        public class TestVolumeComponent0729 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1738575370);
+        }
+[SupportedOn(typeof(TestVolumeComponent0866))]
+[Obsolete]
+        public class TestVolumeComponent0730 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(703569990);
+        }
+[SupportedOn(typeof(TestVolumeComponent0859))]
+        public class TestVolumeComponent0731 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1696627346);
+        }
+[SupportedOn(typeof(TestVolumeComponent0948))]
+[HideInInspector]
+[VolumeComponentMenu("TrLOqEeSs/FrTpgpmOL")]
+        public class TestVolumeComponent0732 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1286872207);
+        }
+[SupportedOn(typeof(TestVolumeComponent0758))]
+[Obsolete]
+        public class TestVolumeComponent0733 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1747219395);
+        }
+[SupportedOn(typeof(TestVolumeComponent0895))]
+[HideInInspector]
+        public class TestVolumeComponent0734 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1086201047);
+        }
+[SupportedOn(typeof(TestVolumeComponent0921))]
+        public class TestVolumeComponent0735 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(568866467);
+        }
+        public class TestVolumeComponent0736 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2010226898);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0737 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(171197049);
+        }
+[SupportedOn(typeof(TestVolumeComponent0975))]
+[SupportedOn(typeof(TestVolumeComponent0890))]
+        public class TestVolumeComponent0738 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(434724974);
+        }
+[SupportedOn(typeof(TestVolumeComponent0883))]
+[SupportedOn(typeof(TestVolumeComponent0882))]
+        public class TestVolumeComponent0739 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(261574846);
+        }
+[Obsolete]
+[VolumeComponentMenu("xoKBjNQuEgxu/_IwjD gdqjcEBKkxRrLYHINdRpJlq/RfoMLOX/qvBGepaxFGZEzdZ/RvutgAsGR/eWPGapRbZfo ZxzQVUc/ZdDKJE_CHpkAVjgtcluAi/mfcQi/qG_ mKHbBhDGa")]
+        public class TestVolumeComponent0740 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1002862499);
+        }
+[SupportedOn(typeof(TestVolumeComponent0838))]
+[SupportedOn(typeof(TestVolumeComponent0793))]
+        public class TestVolumeComponent0741 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(783512188);
+        }
+[SupportedOn(typeof(TestVolumeComponent0914))]
+[SupportedOn(typeof(TestVolumeComponent0905))]
+[VolumeComponentMenu("ZhLQHbc/wde/PWzjafR VtglcUZGcbNUFCgQcfcnkdmIkYgCaEiELWmrLlg POgILAgpBQmOoKHpLdNfBGaMFdPvLlXAa ivFWoEm RhmQm/BhHAmYFUepubzUmluGzxZQmWk/LSerLKLSaUFKaGsGNxcIJpDCPYB avm NAPYVELYLKi")]
+        public class TestVolumeComponent0742 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1095269709);
+        }
+[SupportedOn(typeof(TestVolumeComponent0828))]
+[SupportedOn(typeof(TestVolumeComponent0791))]
+[Obsolete]
+        public class TestVolumeComponent0743 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1090104874);
+        }
+        public class TestVolumeComponent0744 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1257568053);
+        }
+        public class TestVolumeComponent0745 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(386311709);
+        }
+[SupportedOn(typeof(TestVolumeComponent0848))]
+[HideInInspector]
+        public class TestVolumeComponent0746 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1088399072);
+        }
+[VolumeComponentMenu("YHMJMTnPAVGaYF")]
+        public class TestVolumeComponent0747 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1621386991);
+        }
+[HideInInspector]
+[VolumeComponentMenu("VpidTWXdi/JngS_CDbVpo/sAwbZQNxmEahwW_bFOejVYPtDjoj_UuOifsSe stoAaYzOw")]
+        public class TestVolumeComponent0748 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1821905037);
+        }
+[SupportedOn(typeof(TestVolumeComponent0962))]
+        public class TestVolumeComponent0749 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1555425649);
+        }
+[SupportedOn(typeof(TestVolumeComponent0971))]
+        public class TestVolumeComponent0750 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2107623541);
+        }
+[SupportedOn(typeof(TestVolumeComponent0916))]
+[SupportedOn(typeof(TestVolumeComponent0815))]
+[HideInInspector]
+        public class TestVolumeComponent0751 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(70015865);
+        }
+[SupportedOn(typeof(TestVolumeComponent0989))]
+[SupportedOn(typeof(TestVolumeComponent0904))]
+        public class TestVolumeComponent0752 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2029006190);
+        }
+[SupportedOn(typeof(TestVolumeComponent0897))]
+        public class TestVolumeComponent0753 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1452648026);
+        }
+[SupportedOn(typeof(TestVolumeComponent0794))]
+[SupportedOn(typeof(TestVolumeComponent0001))]
+[HideInInspector]
+[VolumeComponentMenu("tZKqGclg/mbLSPvgMeGiUwpVraAa/BIHvkY_heOkneUB ajPOHd_KTCcnFporcrJIqCctznqjg/PteUuMujDtZhoperaO_CeYZtBxTMaO_YLnPELlwIL gMXfNWktBpJAslRKoxPSw")]
+        public class TestVolumeComponent0754 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(225153187);
+        }
+        public class TestVolumeComponent0755 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(203052151);
+        }
+[SupportedOn(typeof(TestVolumeComponent0006))]
+[VolumeComponentMenu("hujRGgIJjFtROFSoSovsSLWJpkEF eOgfHpP/udZvqbwfcWHYsrZjDdoWXjwUJ JWwfgnLOFvDbPWXCZGzAqIork/mWaC_nHIPKzlDOsMZAVUsrB/g/mjgAwpNtNrH wOuC_toEuvVpVKmjk cKgxJ/w/TY_")]
+        public class TestVolumeComponent0756 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1433333601);
+        }
+[SupportedOn(typeof(TestVolumeComponent0946))]
+[Obsolete]
+        public class TestVolumeComponent0757 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(603922021);
+        }
+        public class TestVolumeComponent0758 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1833895981);
+        }
+[SupportedOn(typeof(TestVolumeComponent0893))]
+[SupportedOn(typeof(TestVolumeComponent0964))]
+[HideInInspector]
+        public class TestVolumeComponent0759 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1892837689);
+        }
+[Obsolete]
+        public class TestVolumeComponent0760 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1724838164);
+        }
+        public class TestVolumeComponent0761 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1064479736);
+        }
+[SupportedOn(typeof(TestVolumeComponent0958))]
+[SupportedOn(typeof(TestVolumeComponent0869))]
+[HideInInspector]
+        public class TestVolumeComponent0762 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(502242500);
+        }
+        public class TestVolumeComponent0763 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1912159571);
+        }
+[SupportedOn(typeof(TestVolumeComponent0957))]
+        public class TestVolumeComponent0764 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1679848071);
+        }
+[SupportedOn(typeof(TestVolumeComponent0966))]
+[HideInInspector]
+        public class TestVolumeComponent0765 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(361498579);
+        }
+[VolumeComponentMenu("TKBjaQktoAFSaxBvVGijFlktVYROXUkUBt_/J _nRCJveURvXbeS_bgdPWZYLWoSRSLEZxHUXhkhoYeCmKLKFdzAgKP JbPGuCeSPGHnThZGu/JCXdRhZYZxzSBIXpcjJYsdmjiGstkdJEVYLxHbFOaCzWJYoIkGgI_IBtLfzrPrJ")]
+        public class TestVolumeComponent0766 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1910193917);
+        }
+        public class TestVolumeComponent0767 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(529446533);
+        }
+        public class TestVolumeComponent0768 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(18584744);
+        }
+[SupportedOn(typeof(TestVolumeComponent0972))]
+        public class TestVolumeComponent0769 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(618825420);
+        }
+        public class TestVolumeComponent0770 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1238809264);
+        }
+[SupportedOn(typeof(TestVolumeComponent0887))]
+[SupportedOn(typeof(TestVolumeComponent0926))]
+[Obsolete]
+        public class TestVolumeComponent0771 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1206741908);
+        }
+[SupportedOn(typeof(TestVolumeComponent0871))]
+        public class TestVolumeComponent0772 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(361287672);
+        }
+[SupportedOn(typeof(TestVolumeComponent0880))]
+[SupportedOn(typeof(TestVolumeComponent0979))]
+        public class TestVolumeComponent0773 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2005238685);
+        }
+[SupportedOn(typeof(TestVolumeComponent0876))]
+[HideInInspector]
+        public class TestVolumeComponent0774 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1611384416);
+        }
+[SupportedOn(typeof(TestVolumeComponent0834))]
+[Obsolete]
+[VolumeComponentMenu("w/DfRfZIwSRYcvcGZlFfgCabF")]
+        public class TestVolumeComponent0775 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(528162925);
+        }
+[SupportedOn(typeof(TestVolumeComponent0925))]
+        public class TestVolumeComponent0776 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(644088913);
+        }
+[SupportedOn(typeof(TestVolumeComponent0934))]
+[SupportedOn(typeof(TestVolumeComponent0913))]
+[Obsolete]
+        public class TestVolumeComponent0777 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1143538374);
+        }
+        public class TestVolumeComponent0778 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1877623129);
+        }
+[SupportedOn(typeof(TestVolumeComponent0952))]
+[Obsolete]
+[VolumeComponentMenu("V/m/HCZncQRALEFdwEo")]
+        public class TestVolumeComponent0779 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1524453647);
+        }
+[SupportedOn(typeof(TestVolumeComponent0805))]
+[Obsolete]
+        public class TestVolumeComponent0780 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1862461507);
+        }
+[Obsolete]
+        public class TestVolumeComponent0781 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2009462615);
+        }
+        public class TestVolumeComponent0782 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1436717038);
+        }
+        public class TestVolumeComponent0783 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1291971494);
+        }
+[SupportedOn(typeof(TestVolumeComponent0848))]
+[HideInInspector]
+        public class TestVolumeComponent0784 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2136899321);
+        }
+[Obsolete]
+        public class TestVolumeComponent0785 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2064879465);
+        }
+        public class TestVolumeComponent0786 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(59896356);
+        }
+[SupportedOn(typeof(TestVolumeComponent0918))]
+[SupportedOn(typeof(TestVolumeComponent0969))]
+[HideInInspector]
+        public class TestVolumeComponent0787 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1362948232);
+        }
+[SupportedOn(typeof(TestVolumeComponent0927))]
+[SupportedOn(typeof(TestVolumeComponent0834))]
+[HideInInspector]
+        public class TestVolumeComponent0788 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(472023980);
+        }
+[SupportedOn(typeof(TestVolumeComponent0936))]
+[SupportedOn(typeof(TestVolumeComponent0987))]
+        public class TestVolumeComponent0789 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2038770521);
+        }
+[SupportedOn(typeof(TestVolumeComponent0980))]
+[Obsolete]
+        public class TestVolumeComponent0790 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1212100629);
+        }
+[SupportedOn(typeof(TestVolumeComponent0941))]
+[HideInInspector]
+        public class TestVolumeComponent0791 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(510927064);
+        }
+[SupportedOn(typeof(TestVolumeComponent0835))]
+[SupportedOn(typeof(TestVolumeComponent0806))]
+        public class TestVolumeComponent0792 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(22481981);
+        }
+[SupportedOn(typeof(TestVolumeComponent0959))]
+[SupportedOn(typeof(TestVolumeComponent0838))]
+        public class TestVolumeComponent0793 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1929164157);
+        }
+        public class TestVolumeComponent0794 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1617897221);
+        }
+[SupportedOn(typeof(TestVolumeComponent0913))]
+[VolumeComponentMenu("YgCgOFARrVSFOiQuERQctkQXjFOcYwtiCPKiAzrZAHpXreKJGHpgYHQDKZlLAmrTUXYqYF/exRxkbJET")]
+        public class TestVolumeComponent0795 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1768805101);
+        }
+        public class TestVolumeComponent0796 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(172143061);
+        }
+[SupportedOn(typeof(TestVolumeComponent0819))]
+[SupportedOn(typeof(TestVolumeComponent0954))]
+[HideInInspector]
+        public class TestVolumeComponent0797 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(376596545);
+        }
+[SupportedOn(typeof(TestVolumeComponent0940))]
+        public class TestVolumeComponent0798 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1261848061);
+        }
+        public class TestVolumeComponent0799 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(95576960);
+        }
+[SupportedOn(typeof(TestVolumeComponent0923))]
+[SupportedOn(typeof(TestVolumeComponent0830))]
+        public class TestVolumeComponent0800 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1462598597);
+        }
+[SupportedOn(typeof(TestVolumeComponent0047))]
+        public class TestVolumeComponent0801 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1167907633);
+        }
+[SupportedOn(typeof(TestVolumeComponent0912))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0802 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1442724116);
+        }
+[Obsolete]
+        public class TestVolumeComponent0803 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(365682371);
+        }
+[Obsolete]
+        public class TestVolumeComponent0804 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(287615959);
+        }
+[SupportedOn(typeof(TestVolumeComponent0991))]
+        public class TestVolumeComponent0805 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1669852579);
+        }
+        public class TestVolumeComponent0806 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1018586066);
+        }
+[SupportedOn(typeof(TestVolumeComponent0998))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0807 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1895773561);
+        }
+[SupportedOn(typeof(TestVolumeComponent0045))]
+[HideInInspector]
+        public class TestVolumeComponent0808 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(748262377);
+        }
+[SupportedOn(typeof(TestVolumeComponent0031))]
+[SupportedOn(typeof(TestVolumeComponent0926))]
+        public class TestVolumeComponent0809 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1469649473);
+        }
+[SupportedOn(typeof(TestVolumeComponent0935))]
+[VolumeComponentMenu("XGDfwEVbiduCoSknoQmSmjw orexgENUFjc")]
+        public class TestVolumeComponent0810 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1407531519);
+        }
+        public class TestVolumeComponent0811 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1532939819);
+        }
+[SupportedOn(typeof(TestVolumeComponent0942))]
+[SupportedOn(typeof(TestVolumeComponent0941))]
+        public class TestVolumeComponent0812 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1873395047);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0813 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1907131998);
+        }
+[SupportedOn(typeof(TestVolumeComponent0869))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0814 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(62177765);
+        }
+[SupportedOn(typeof(TestVolumeComponent0948))]
+        public class TestVolumeComponent0815 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(135651817);
+        }
+[SupportedOn(typeof(TestVolumeComponent0021))]
+[SupportedOn(typeof(TestVolumeComponent0872))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0816 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(551701177);
+        }
+[Obsolete]
+        public class TestVolumeComponent0817 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2103343252);
+        }
+        public class TestVolumeComponent0818 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1125128568);
+        }
+[VolumeComponentMenu("w/mbDnLI_OoYXjq TMabVpqrBAsWit_WktgfZhqCJrzf_/FSFpwvuGHOqfBxRrPEqOwrmhifHjJKgSznub_GcrFSREsU_rRAsUVta exaGNOgSwjJ/odPQaUenRtFQqrgfJMmlZjFKP/wjkOPpapLI_xwhstcCTjLKoKLpLncIPGcjspBSFWZUiOaQFKVlo")]
+        public class TestVolumeComponent0819 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(956460159);
+        }
+[SupportedOn(typeof(TestVolumeComponent0069))]
+[SupportedOn(typeof(TestVolumeComponent0944))]
+[Obsolete]
+        public class TestVolumeComponent0820 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(701292480);
+        }
+        public class TestVolumeComponent0821 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(678300647);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0822 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1429532894);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0823 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1753606245);
+        }
+[SupportedOn(typeof(TestVolumeComponent0957))]
+        public class TestVolumeComponent0824 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(332938345);
+        }
+[Obsolete]
+        public class TestVolumeComponent0825 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1578694457);
+        }
+[SupportedOn(typeof(TestVolumeComponent0952))]
+[HideInInspector]
+        public class TestVolumeComponent0826 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(564005652);
+        }
+        public class TestVolumeComponent0827 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1098639864);
+        }
+[SupportedOn(typeof(TestVolumeComponent0024))]
+[SupportedOn(typeof(TestVolumeComponent0935))]
+[HideInInspector]
+        public class TestVolumeComponent0828 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1467349700);
+        }
+        public class TestVolumeComponent0829 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1063622483);
+        }
+        public class TestVolumeComponent0830 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2060968455);
+        }
+[VolumeComponentMenu("FtavNKqARWo DpmMqrLYBtRMcdabJIJQRvJSzGRWzUiOupBQRpilD")]
+        public class TestVolumeComponent0831 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1276223677);
+        }
+[SupportedOn(typeof(TestVolumeComponent0885))]
+[VolumeComponentMenu("qGFUinDUqfPAcQFdJQoMaIkxmbqlNKFGcrDfPSPdurmOVULbVtifJpkMqlPlZjNUmMVAoKJYgMNYulidovmEqAkMmjDUVIsjeUFGXIVQelwpgtqAJIFY_IDtFfzdsnuYFK_tqEsSTrc")]
+        public class TestVolumeComponent0832 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1072305103);
+        }
+        public class TestVolumeComponent0833 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1116849947);
+        }
+[SupportedOn(typeof(TestVolumeComponent0932))]
+        public class TestVolumeComponent0834 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(354460055);
+        }
+[SupportedOn(typeof(TestVolumeComponent0893))]
+[SupportedOn(typeof(TestVolumeComponent0876))]
+        public class TestVolumeComponent0835 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(157888875);
+        }
+        public class TestVolumeComponent0836 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1833053407);
+        }
+        public class TestVolumeComponent0837 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2113570230);
+        }
+[SupportedOn(typeof(TestVolumeComponent0005))]
+        public class TestVolumeComponent0838 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1770238074);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("YRODUehwnmheCTYNCzAgAslNSNKBn_nLKzfudVERfDCz uOoIcMzKJbXGPSNKaKgWoIRGBWqOFWJGRMitmvsxLtNdLdDxcdD H FjgCaCu kMoxaKoj_KVSVpwAsjBfH zjenHnirgUFvoQufqhNWkxFGzpm LKsQwrFKZrsdHlz zxoOipJKV/e/mQwhoherFAurV q")]
+        public class TestVolumeComponent0839 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1477129573);
+        }
+[SupportedOn(typeof(TestVolumeComponent0973))]
+[SupportedOn(typeof(TestVolumeComponent0064))]
+        public class TestVolumeComponent0840 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(799819842);
+        }
+[SupportedOn(typeof(TestVolumeComponent0897))]
+[SupportedOn(typeof(TestVolumeComponent0848))]
+[HideInInspector]
+        public class TestVolumeComponent0841 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(886539838);
+        }
+[SupportedOn(typeof(TestVolumeComponent0890))]
+[Obsolete]
+        public class TestVolumeComponent0842 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(672942634);
+        }
+[SupportedOn(typeof(TestVolumeComponent0043))]
+        public class TestVolumeComponent0843 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1047587430);
+        }
+[SupportedOn(typeof(TestVolumeComponent0036))]
+        public class TestVolumeComponent0844 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(357731250);
+        }
+[SupportedOn(typeof(TestVolumeComponent0869))]
+[SupportedOn(typeof(TestVolumeComponent0012))]
+        public class TestVolumeComponent0845 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(968645370);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("vNtDOexgYJIZdivRdkjBYNxihVrwbgAFIwMmUDEargIgrefJGoSD/FCVhTpHMabDQ_YXruQLjmlRSPdzGkxsQ_nuGmraIJMgrkdDWqrHIPSFITATlZjTCNGTjmlwle gSkxwELGBpN NOeSuWzUmIwYHtZGiOi PAiGFvXURxkGBfRj_SDMz/ZU_ sjzMLtDC_CLMFvo")]
+        public class TestVolumeComponent0846 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(658439141);
+        }
+[SupportedOn(typeof(TestVolumeComponent0980))]
+[SupportedOn(typeof(TestVolumeComponent0071))]
+        public class TestVolumeComponent0847 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1501840578);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0848 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(765094073);
+        }
+[SupportedOn(typeof(TestVolumeComponent0975))]
+[SupportedOn(typeof(TestVolumeComponent0934))]
+[VolumeComponentMenu("mUqlRQznFAVdzGL/LfDvwCqCstBGwWHO_ Bt_IXheQstcvc/DvHbRCopstiporHpRSkG_/HtXpeQR gETGwbFCFIRUiUBxshNIFAudDOubwONSJvJENjL/g T/BjLIztTrTQNnwEcO_IBMi BlZtmQwWJGqENEkATEXMPlXpw/wvNUmOLEzSipsIJtXp_MHSoUVCPhkWipgKXtTERKR/mWonRGkKBMixixsdeWo/aYw")]
+        public class TestVolumeComponent0849 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(438552399);
+        }
+[SupportedOn(typeof(TestVolumeComponent0003))]
+        public class TestVolumeComponent0850 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1356451715);
+        }
+        public class TestVolumeComponent0851 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1817843479);
+        }
+[SupportedOn(typeof(TestVolumeComponent0910))]
+        public class TestVolumeComponent0852 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1514303203);
+        }
+        public class TestVolumeComponent0853 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1560913298);
+        }
+        public class TestVolumeComponent0854 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(395026610);
+        }
+        public class TestVolumeComponent0855 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1386555933);
+        }
+[SupportedOn(typeof(TestVolumeComponent0101))]
+[SupportedOn(typeof(TestVolumeComponent0872))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("bT/kdD/PtFKHGXdgvFETjLjHOu FIVGkfD LbeAiYu/uhq XnDEZlDj_fihkjspF abLjcARAHxB/PUZvqSZtgdglHrBlcIkSuOB R eQTbBtelVxiERbsQDQNnkWVWzKznBOVroOTlwtabsvqSwrBWcbkA_nqxB/VQJpkvgpqvV/DdV NMspc/RxBfBKahFADvBbJOZ")]
+        public class TestVolumeComponent0856 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1779897573);
+        }
+[SupportedOn(typeof(TestVolumeComponent0990))]
+[SupportedOn(typeof(TestVolumeComponent0081))]
+        public class TestVolumeComponent0857 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1976637890);
+        }
+[SupportedOn(typeof(TestVolumeComponent0914))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0858 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(894631353);
+        }
+[Obsolete]
+        public class TestVolumeComponent0859 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1685401492);
+        }
+        public class TestVolumeComponent0860 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1365762168);
+        }
+[VolumeComponentMenu("FELOPtDpe sfFjJAZELvPrsOchDjqUgOefsGLMcxzxsEV HjJOsQHxspgYsSXQ_GcINvRQoncfkMZdBxmbuAVtDYwtBluCc VSeCNEaKelJWeWBOXKmKclF NdZKobaAZKmvRnqCDMTnDrJOcdTjXfcMZrsrXbgrBbHILQLdg JQHnFOipHAqpmQXMFO_lm")]
+        public class TestVolumeComponent0861 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(757889919);
+        }
+        public class TestVolumeComponent0862 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(240030123);
+        }
+        public class TestVolumeComponent0863 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2143207770);
+        }
+[SupportedOn(typeof(TestVolumeComponent0071))]
+[SupportedOn(typeof(TestVolumeComponent0954))]
+[HideInInspector]
+        public class TestVolumeComponent0864 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1233817566);
+        }
+[SupportedOn(typeof(TestVolumeComponent0920))]
+[SupportedOn(typeof(TestVolumeComponent0883))]
+        public class TestVolumeComponent0865 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1198983535);
+        }
+[SupportedOn(typeof(TestVolumeComponent0036))]
+        public class TestVolumeComponent0866 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1474066843);
+        }
+[SupportedOn(typeof(TestVolumeComponent0965))]
+[SupportedOn(typeof(TestVolumeComponent0900))]
+        public class TestVolumeComponent0867 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(34025911);
+        }
+        public class TestVolumeComponent0868 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1924499427);
+        }
+        public class TestVolumeComponent0869 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1609786002);
+        }
+[SupportedOn(typeof(TestVolumeComponent0933))]
+[SupportedOn(typeof(TestVolumeComponent0008))]
+        public class TestVolumeComponent0870 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1214998923);
+        }
+[SupportedOn(typeof(TestVolumeComponent0937))]
+        public class TestVolumeComponent0871 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1853068551);
+        }
+[SupportedOn(typeof(TestVolumeComponent0898))]
+[Obsolete]
+        public class TestVolumeComponent0872 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(826063059);
+        }
+[VolumeComponentMenu("NlZpTSwhBrLpXSRURQNEovz ZMZ/XWZxVpifZrP B/TfoxVSzrcfNEqMolsUspLAoGJAgbBnTKctN/_SHtiUwbzCodNIBGJCiSFOofVSRbRlabzSVIuUwxzALMV q oGgdqCqOmtRIZnVhDYZMPOuKTtRIcUk/qET/H/XKZKNbPOa")]
+        public class TestVolumeComponent0873 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1857411069);
+        }
+        public class TestVolumeComponent0874 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1540152197);
+        }
+[SupportedOn(typeof(TestVolumeComponent0993))]
+[VolumeComponentMenu("xJSXhPEqxNWJEz/alwYTjeABjcIcniMwtajDS_tJpmQLCHlDnwdF/zvNMDO_CFCF/knRvBlFUH/TEsps")]
+        public class TestVolumeComponent0875 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(285225325);
+        }
+        public class TestVolumeComponent0876 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(780163669);
+        }
+[SupportedOn(typeof(TestVolumeComponent0899))]
+[Obsolete]
+        public class TestVolumeComponent0877 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1258205377);
+        }
+        public class TestVolumeComponent0878 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(946128572);
+        }
+[SupportedOn(typeof(TestVolumeComponent0058))]
+        public class TestVolumeComponent0879 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2017275392);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0880 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1673150119);
+        }
+[SupportedOn(typeof(TestVolumeComponent0890))]
+[SupportedOn(typeof(TestVolumeComponent0021))]
+        public class TestVolumeComponent0881 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1137555144);
+        }
+[SupportedOn(typeof(TestVolumeComponent0982))]
+[SupportedOn(typeof(TestVolumeComponent0957))]
+[HideInInspector]
+        public class TestVolumeComponent0882 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1415142804);
+        }
+[SupportedOn(typeof(TestVolumeComponent0103))]
+[SupportedOn(typeof(TestVolumeComponent0966))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0883 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1527788867);
+        }
+[SupportedOn(typeof(TestVolumeComponent0045))]
+[HideInInspector]
+        public class TestVolumeComponent0884 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(574484567);
+        }
+[SupportedOn(typeof(TestVolumeComponent0071))]
+        public class TestVolumeComponent0885 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(442234403);
+        }
+[SupportedOn(typeof(TestVolumeComponent0000))]
+[SupportedOn(typeof(TestVolumeComponent0999))]
+        public class TestVolumeComponent0886 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1161704159);
+        }
+        public class TestVolumeComponent0887 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(742752459);
+        }
+[SupportedOn(typeof(TestVolumeComponent0082))]
+[SupportedOn(typeof(TestVolumeComponent0953))]
+        public class TestVolumeComponent0888 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1165183815);
+        }
+        public class TestVolumeComponent0889 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2103153939);
+        }
+[SupportedOn(typeof(TestVolumeComponent0972))]
+[SupportedOn(typeof(TestVolumeComponent0907))]
+[Obsolete]
+        public class TestVolumeComponent0890 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(131729839);
+        }
+[SupportedOn(typeof(TestVolumeComponent0980))]
+        public class TestVolumeComponent0891 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1921276643);
+        }
+        public class TestVolumeComponent0892 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(139048503);
+        }
+[Obsolete]
+[VolumeComponentMenu("VjkpeQLjqYabiWa sIJrTbqYRUBfmlgQoCaGcONnivqQeUXMsOTQqYZANUutPGPtLpHdzINrNGNhmYoAslzKcQoCNOXKo/qlqhZKqnzbTdDxFOBQwjirNvqCLtkYTOz/DOZhqGchcIohqvBxDAiQe")]
+        public class TestVolumeComponent0893 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(557319357);
+        }
+        public class TestVolumeComponent0894 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1477629125);
+        }
+[SupportedOn(typeof(TestVolumeComponent0141))]
+        public class TestVolumeComponent0895 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1871858737);
+        }
+[SupportedOn(typeof(TestVolumeComponent0006))]
+[SupportedOn(typeof(TestVolumeComponent0901))]
+[HideInInspector]
+[VolumeComponentMenu("YPtulXWBxmUZAsfPxXIzvZdJ")]
+        public class TestVolumeComponent0896 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1302969205);
+        }
+[SupportedOn(typeof(TestVolumeComponent0062))]
+[Obsolete]
+        public class TestVolumeComponent0897 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1512450681);
+        }
+[SupportedOn(typeof(TestVolumeComponent0135))]
+[SupportedOn(typeof(TestVolumeComponent0050))]
+        public class TestVolumeComponent0898 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1415489646);
+        }
+        public class TestVolumeComponent0899 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(129764161);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0900 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1475508232);
+        }
+[SupportedOn(typeof(TestVolumeComponent0040))]
+[Obsolete]
+        public class TestVolumeComponent0901 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1851651884);
+        }
+[SupportedOn(typeof(TestVolumeComponent0049))]
+        public class TestVolumeComponent0902 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(860454768);
+        }
+[SupportedOn(typeof(TestVolumeComponent0994))]
+[HideInInspector]
+        public class TestVolumeComponent0903 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(735178940);
+        }
+[SupportedOn(typeof(TestVolumeComponent0948))]
+[SupportedOn(typeof(TestVolumeComponent0939))]
+[HideInInspector]
+[VolumeComponentMenu("KzYwKFQXKZKsbejTlTAcrXbkCuhNdgtROmbXhRbwIgSFMPGgKzYiAqxFQzrqlTdLGmbV/XtzAiURIZtD/mGsrXUNjTIPhi DQLYHCJnL/L JjDOmCwC_fspJtFAJ JGDfq XUBMTEJ/BUDbDjqdPQq")]
+        public class TestVolumeComponent0904 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(125849511);
+        }
+[SupportedOn(typeof(TestVolumeComponent0914))]
+        public class TestVolumeComponent0905 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1788038107);
+        }
+[SupportedOn(typeof(TestVolumeComponent0115))]
+[VolumeComponentMenu("kANpe/XANnBMg PSJlT NOexcxqCwIRpkbut_hZdF/FKVlZQgdVWVMsnHfZrZOsfiMwOwdiETIPQVAwOTAcAFWqYRIm avL")]
+        public class TestVolumeComponent0906 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1613346175);
+        }
+[SupportedOn(typeof(TestVolumeComponent0156))]
+[VolumeComponentMenu("VWRUmfcnafqrTdV/FnDMqriMzCTjHjDWXtBIenFADdidLpsrwAHGLpFYVpX qGDvT FfsYZGelFvXKJfLfJWHWs")]
+        public class TestVolumeComponent0907 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1228918511);
+        }
+[SupportedOn(typeof(TestVolumeComponent0125))]
+[SupportedOn(typeof(TestVolumeComponent0936))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0908 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1055394939);
+        }
+[SupportedOn(typeof(TestVolumeComponent0943))]
+[SupportedOn(typeof(TestVolumeComponent0006))]
+        public class TestVolumeComponent0909 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1112638551);
+        }
+[SupportedOn(typeof(TestVolumeComponent0015))]
+[Obsolete]
+        public class TestVolumeComponent0910 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(449931403);
+        }
+[SupportedOn(typeof(TestVolumeComponent0960))]
+        public class TestVolumeComponent0911 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(610606271);
+        }
+[SupportedOn(typeof(TestVolumeComponent0033))]
+[Obsolete]
+        public class TestVolumeComponent0912 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1937793523);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("lXCVfuWibeUVrgpmdPrTEJYqUDpFrNOqlzEwfBfsn_Ik/_fXWcYXKuEHrBSFWcdshoQXjcdkbgMqK_WBnepZWcxBWkjirJEVOP B/_lgSNOsbmvkhLdoWejzEo")]
+        public class TestVolumeComponent0913 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1108196403);
+        }
+[SupportedOn(typeof(TestVolumeComponent0043))]
+[SupportedOn(typeof(TestVolumeComponent0062))]
+        public class TestVolumeComponent0914 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(138818604);
+        }
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0915 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(204129374);
+        }
+[SupportedOn(typeof(TestVolumeComponent0971))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0916 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(136458213);
+        }
+[SupportedOn(typeof(TestVolumeComponent0050))]
+        public class TestVolumeComponent0917 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1213382633);
+        }
+[Obsolete]
+        public class TestVolumeComponent0918 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(339313849);
+        }
+[SupportedOn(typeof(TestVolumeComponent0045))]
+[HideInInspector]
+        public class TestVolumeComponent0919 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(905717396);
+        }
+        public class TestVolumeComponent0920 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1469203320);
+        }
+[SupportedOn(typeof(TestVolumeComponent0117))]
+[SupportedOn(typeof(TestVolumeComponent0028))]
+[HideInInspector]
+        public class TestVolumeComponent0921 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1925497924);
+        }
+[SupportedOn(typeof(TestVolumeComponent0982))]
+[SupportedOn(typeof(TestVolumeComponent0037))]
+[Obsolete]
+        public class TestVolumeComponent0922 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1444986208);
+        }
+[VolumeComponentMenu("lL/DrZ NAJKgrR")]
+        public class TestVolumeComponent0923 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1405717871);
+        }
+[SupportedOn(typeof(TestVolumeComponent0141))]
+[SupportedOn(typeof(TestVolumeComponent0952))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0924 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1711135995);
+        }
+[SupportedOn(typeof(TestVolumeComponent0959))]
+[SupportedOn(typeof(TestVolumeComponent0022))]
+        public class TestVolumeComponent0925 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(390509271);
+        }
+[VolumeComponentMenu("QHngMNjZpLKetLUo/kMTlevPWmEwfTGoELjNEXnsp_dDCPvwpXKkWVpsKBUuELWmUgh_MLpcMsnP w wpLva/JWDxDjJOg/XvsbiSB/PteAkjNvzIVGwpkIkGzKgEkpLCqCHSPrJdZdkngxmrmlRSPrLbPMo")]
+        public class TestVolumeComponent0926 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(2141763425);
+        }
+[SupportedOn(typeof(TestVolumeComponent0116))]
+[SupportedOn(typeof(TestVolumeComponent0159))]
+[HideInInspector]
+        public class TestVolumeComponent0927 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(997705317);
+        }
+[SupportedOn(typeof(TestVolumeComponent0061))]
+        public class TestVolumeComponent0928 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1494989417);
+        }
+[SupportedOn(typeof(TestVolumeComponent0134))]
+[SupportedOn(typeof(TestVolumeComponent0985))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0929 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1398133049);
+        }
+[SupportedOn(typeof(TestVolumeComponent0056))]
+[HideInInspector]
+        public class TestVolumeComponent0930 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(685472020);
+        }
+[SupportedOn(typeof(TestVolumeComponent0030))]
+        public class TestVolumeComponent0931 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1007854968);
+        }
+[SupportedOn(typeof(TestVolumeComponent0039))]
+[HideInInspector]
+        public class TestVolumeComponent0932 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(504136900);
+        }
+        public class TestVolumeComponent0933 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1455514963);
+        }
+[SupportedOn(typeof(TestVolumeComponent0127))]
+[SupportedOn(typeof(TestVolumeComponent0018))]
+[VolumeComponentMenu("YNOLpBGNYXpD/m")]
+        public class TestVolumeComponent0934 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(591081455);
+        }
+[HideInInspector]
+[VolumeComponentMenu("gIBSFQLOaUPrPxFdinL BSTAPMmdoWqtT/XKwEFGJdwEsAPtkWFOsl_viCVvwbHdZdNMT")]
+        public class TestVolumeComponent0935 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1008476557);
+        }
+        public class TestVolumeComponent0936 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2129824437);
+        }
+[SupportedOn(typeof(TestVolumeComponent0151))]
+[SupportedOn(typeof(TestVolumeComponent0158))]
+        public class TestVolumeComponent0937 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1512047989);
+        }
+[VolumeComponentMenu("SqW_biCzMcdcMqtuCBlTtqADjNbalHfJQzMgna/Fn_tFUFUTpPSaUZIejmAwGJlHAwQ_Qkfu JIsKidqjBWirapoAR wxX wKNATnDtZrFdqSapFAztz/NYsURlsWwxsUHdzQLbLGcMwvwEJhkQR RbwlNOifZCctP/RvzlXtJxahPWkEo c/qWR")]
+        public class TestVolumeComponent0938 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1563990613);
+        }
+[SupportedOn(typeof(TestVolumeComponent0040))]
+[SupportedOn(typeof(TestVolumeComponent0067))]
+        public class TestVolumeComponent0939 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1436108050);
+        }
+[Obsolete]
+[VolumeComponentMenu("PCwWiYLfFKRlHCkYNdo")]
+        public class TestVolumeComponent0940 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(306551055);
+        }
+[SupportedOn(typeof(TestVolumeComponent0966))]
+[SupportedOn(typeof(TestVolumeComponent0161))]
+[HideInInspector]
+        public class TestVolumeComponent0941 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1539690563);
+        }
+[Obsolete]
+        public class TestVolumeComponent0942 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1878859607);
+        }
+[SupportedOn(typeof(TestVolumeComponent0129))]
+        public class TestVolumeComponent0943 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1911552291);
+        }
+[SupportedOn(typeof(TestVolumeComponent0058))]
+[SupportedOn(typeof(TestVolumeComponent0057))]
+        public class TestVolumeComponent0944 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(393614815);
+        }
+[SupportedOn(typeof(TestVolumeComponent0130))]
+[SupportedOn(typeof(TestVolumeComponent0133))]
+        public class TestVolumeComponent0945 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(433617632);
+        }
+        public class TestVolumeComponent0946 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1779498567);
+        }
+[SupportedOn(typeof(TestVolumeComponent0020))]
+        public class TestVolumeComponent0947 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1456749179);
+        }
+[SupportedOn(typeof(TestVolumeComponent0965))]
+[Obsolete]
+        public class TestVolumeComponent0948 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1927267503);
+        }
+[SupportedOn(typeof(TestVolumeComponent0038))]
+[SupportedOn(typeof(TestVolumeComponent0105))]
+        public class TestVolumeComponent0949 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(413968720);
+        }
+[VolumeComponentMenu("TKkADtRYqQPtRtDKgYFjDtsx_lqheSPY_UafVxklJUHlLYzjDYZpZAoMNpsSutXCaEXjFMofRGZ spFMoUBMZGkl_KNlLAeKoOFWqxZfcGRv_UR")]
+        public class TestVolumeComponent0950 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(557816047);
+        }
+[SupportedOn(typeof(TestVolumeComponent0168))]
+[SupportedOn(typeof(TestVolumeComponent0979))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0951 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(306285179);
+        }
+[SupportedOn(typeof(TestVolumeComponent0986))]
+        public class TestVolumeComponent0952 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1526451703);
+        }
+        public class TestVolumeComponent0953 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1099950798);
+        }
+[SupportedOn(typeof(TestVolumeComponent0977))]
+[HideInInspector]
+        public class TestVolumeComponent0954 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1236520774);
+        }
+[SupportedOn(typeof(TestVolumeComponent0083))]
+        public class TestVolumeComponent0955 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1155505554);
+        }
+[SupportedOn(typeof(TestVolumeComponent0172))]
+[SupportedOn(typeof(TestVolumeComponent0187))]
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("X al_vLIaIcYiMREXUZ")]
+        public class TestVolumeComponent0956 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1571150735);
+        }
+[SupportedOn(typeof(TestVolumeComponent0982))]
+[SupportedOn(typeof(TestVolumeComponent0177))]
+[HideInInspector]
+        public class TestVolumeComponent0957 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(336062147);
+        }
+[SupportedOn(typeof(TestVolumeComponent0119))]
+[HideInInspector]
+        public class TestVolumeComponent0958 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1980158935);
+        }
+[SupportedOn(typeof(TestVolumeComponent0145))]
+[SupportedOn(typeof(TestVolumeComponent0128))]
+        public class TestVolumeComponent0959 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1811739691);
+        }
+[SupportedOn(typeof(TestVolumeComponent0073))]
+        public class TestVolumeComponent0960 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1165413471);
+        }
+[SupportedOn(typeof(TestVolumeComponent0146))]
+[SupportedOn(typeof(TestVolumeComponent0149))]
+        public class TestVolumeComponent0961 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(925651808);
+        }
+        public class TestVolumeComponent0962 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1754539207);
+        }
+[SupportedOn(typeof(TestVolumeComponent0036))]
+[SupportedOn(typeof(TestVolumeComponent0039))]
+[VolumeComponentMenu("SohDrsSzURdXpkGJORSgQHxHIzATAaAkCsbLhivZAkKPvFjavorLdeGktqfNdulwlFtaKzjslqWHdRYzbHIRUXCNKsQNtudNIuvJpmCFvFbq _YJKuYzpB/ovuruYzxRxzGeSzpPfuhsQROBUNUeSDdcnTEPvTSJrXjwlXOZEzbJKgncGZIsGkIB/mIehZj_dNhiSBfXjuSLUwIcSzEzbgvNrmIzSkfmjqnaOgpspkrkCwlJxwKBMV")]
+        public class TestVolumeComponent0963 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(952962887);
+        }
+[SupportedOn(typeof(TestVolumeComponent0037))]
+[SupportedOn(typeof(TestVolumeComponent0040))]
+[VolumeComponentMenu("ANCX _jXMBnwYwWBQutk/kSeAaAHlHbzlZAkpuYJKsAHOuQZ/XbgOg aQJWPETKo/P/N/TSN/mtNlRrkOcAVbejipDdgtXpVOkGkh_KJns/wMsKwdHxNEiIgYLIehJpzCeILGFhP kWsGFOTtFINxcYNjPxgUL JMRCXfBSzYPhgImpcQeKcOenaCROPlLAVMT e itzte/TSTIsnstLrB mCXQarREBbmIZfLKXpFEkpDjohVCLAz")]
+        public class TestVolumeComponent0964 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1053623751);
+        }
+[SupportedOn(typeof(TestVolumeComponent0038))]
+[SupportedOn(typeof(TestVolumeComponent0041))]
+[VolumeComponentMenu("nVCNxitsdujwSuIF eGHdgA_WuhLOVSqGajqYsxk shPrzCZxTEX/mpkIPKVxZdDjFWTOuveGHxzATvNGgdLAeMsUFlixaCkIaAwvLOHpNbNYTncpNbeABlBUXUHhsrFrmxo cMupXYzMFnNdsWLtLOPrZjenudsIBCRpJIansEzAuEPMNEg XnwUDOHlcKFGgWNUuQFSilaWTSBto/JvaIkvg/BhqCZnVYD/LUJtspo ebZWmtXWL")]
+        public class TestVolumeComponent0965 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(412280903);
+        }
+[SupportedOn(typeof(TestVolumeComponent0039))]
+        public class TestVolumeComponent0966 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(443380859);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("QRbuxTIHpztctP zSmxub_WajJ/mGgdolsrFxTrPtJhHx_ETWuQqAD Jha/cAehTEFdsYDvJtJrRdzQ_EaSavqxNfoEFnmnctmEgfiWqCZGDIsMcCHYwhgrNUsjzMTQXtkUwEPtFIo")]
+        public class TestVolumeComponent0967 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1000948259);
+        }
+        public class TestVolumeComponent0968 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1583557623);
+        }
+[SupportedOn(typeof(TestVolumeComponent0219))]
+[SupportedOn(typeof(TestVolumeComponent0074))]
+[Obsolete]
+        public class TestVolumeComponent0969 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(657611915);
+        }
+        public class TestVolumeComponent0970 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(474368575);
+        }
+[SupportedOn(typeof(TestVolumeComponent0045))]
+[VolumeComponentMenu("tmxTKJ/qfREiveMmITfVEPQL/g PMFjH ebuEDhFIHnNxo/ZKBIVYJOPdJnanwOZdkbDUgxHnLhohwhTCkdkteYNpqxXf_xahXrLpedo/ZSLEFnivuCP/chTYVrXrgtHtZKaCitLlBvmnkEmdJOctmWPhVUFrJhZOHQPQuhzviMg")]
+        public class TestVolumeComponent0971 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1050354097);
+        }
+[SupportedOn(typeof(TestVolumeComponent0065))]
+[SupportedOn(typeof(TestVolumeComponent0172))]
+        public class TestVolumeComponent0972 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1486592742);
+        }
+[SupportedOn(typeof(TestVolumeComponent0165))]
+        public class TestVolumeComponent0973 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1245799474);
+        }
+[SupportedOn(typeof(TestVolumeComponent0998))]
+[SupportedOn(typeof(TestVolumeComponent0141))]
+        public class TestVolumeComponent0974 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1976071546);
+        }
+[SupportedOn(typeof(TestVolumeComponent0990))]
+[VolumeComponentMenu("DAJAq iMmlJUPC_STdD qhPQLKBKB/ZAiMVdJQ_AgbwOPQTIsQHCw")]
+        public class TestVolumeComponent0975 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(418962493);
+        }
+[SupportedOn(typeof(TestVolumeComponent0029))]
+[SupportedOn(typeof(TestVolumeComponent0184))]
+[Obsolete]
+        public class TestVolumeComponent0976 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1122374394);
+        }
+[SupportedOn(typeof(TestVolumeComponent0081))]
+[SupportedOn(typeof(TestVolumeComponent0160))]
+        public class TestVolumeComponent0977 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1385326338);
+        }
+[SupportedOn(typeof(TestVolumeComponent0009))]
+[HideInInspector]
+        public class TestVolumeComponent0978 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2093358466);
+        }
+[SupportedOn(typeof(TestVolumeComponent0163))]
+[SupportedOn(typeof(TestVolumeComponent0114))]
+[VolumeComponentMenu("DAwCmdRUZlsELbHOwWZtiSBrkronRbzxZpVxiQcUgSBCDKwQTxclgQwjmYoAVv_hPAkSaCLhVSHKerTbBSmKgjVrR zQFGPAHEiYipBnL zG_WiCXr_tqCeGHdgMTQaKLKivwKqlgCL crqUcrHxZfzGZANbVpBODIshTrXUTA_nwEwMwhqAipqrLxL/qtsSBQNEohkhmCLUcYupapcO_SNlk/ahinTdRnBAmCXQLbmxaGiGJvLQu VjLGNAz")]
+        public class TestVolumeComponent0979 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(520660365);
+        }
+[SupportedOn(typeof(TestVolumeComponent0193))]
+[SupportedOn(typeof(TestVolumeComponent0156))]
+        public class TestVolumeComponent0980 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(2104147178);
+        }
+        public class TestVolumeComponent0981 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1143970165);
+        }
+[SupportedOn(typeof(TestVolumeComponent0147))]
+[SupportedOn(typeof(TestVolumeComponent0046))]
+[HideInInspector]
+        public class TestVolumeComponent0982 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1684207737);
+        }
+[SupportedOn(typeof(TestVolumeComponent0220))]
+[HideInInspector]
+        public class TestVolumeComponent0983 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(842771177);
+        }
+[SupportedOn(typeof(TestVolumeComponent0206))]
+        public class TestVolumeComponent0984 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1055941797);
+        }
+[SupportedOn(typeof(TestVolumeComponent0167))]
+[HideInInspector]
+        public class TestVolumeComponent0985 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1177433608);
+        }
+[HideInInspector]
+        public class TestVolumeComponent0986 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(106211887);
+        }
+[SupportedOn(typeof(TestVolumeComponent0076))]
+[SupportedOn(typeof(TestVolumeComponent0143))]
+        public class TestVolumeComponent0987 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1623823568);
+        }
+[VolumeComponentMenu("VCwMZADvsvZYsMZSmG_EFIuCiUmlXfNfPONWPYsnBjoKaCmMNdmhsUVO_OJKs/cSXAHYgIFAopzhVladixHreMwrXUqbTjVWPCgQRWeKF/LOcCX")]
+        public class TestVolumeComponent0988 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(255712879);
+        }
+[SupportedOn(typeof(TestVolumeComponent0206))]
+[HideInInspector]
+        public class TestVolumeComponent0989 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(1418132987);
+        }
+[SupportedOn(typeof(TestVolumeComponent0024))]
+[SupportedOn(typeof(TestVolumeComponent0087))]
+        public class TestVolumeComponent0990 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1978512343);
+        }
+[SupportedOn(typeof(TestVolumeComponent0096))]
+[SupportedOn(typeof(TestVolumeComponent0163))]
+[HideInInspector]
+        public class TestVolumeComponent0991 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(536799243);
+        }
+[SupportedOn(typeof(TestVolumeComponent0041))]
+        public class TestVolumeComponent0992 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(315804735);
+        }
+[SupportedOn(typeof(TestVolumeComponent0114))]
+[SupportedOn(typeof(TestVolumeComponent0245))]
+[HideInInspector]
+        public class TestVolumeComponent0993 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(818495859);
+        }
+[Obsolete]
+[HideInInspector]
+[VolumeComponentMenu("/olNO_YsEJlZU_ruYZdeMwKutZSZIoGXpDEoMR V/uYNxmWLrwviOajaUJSXhwGJrgvzWkYofeIkjqIgxDle wjHUm/HhJjDjFpRY_tilzMHMLpVQLxsGR/T/o")]
+        public class TestVolumeComponent0994 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(680807347);
+        }
+        public class TestVolumeComponent0995 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(919361063);
+        }
+[SupportedOn(typeof(TestVolumeComponent0086))]
+[SupportedOn(typeof(TestVolumeComponent0133))]
+[Obsolete]
+[HideInInspector]
+        public class TestVolumeComponent0996 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1261066206);
+        }
+[SupportedOn(typeof(TestVolumeComponent0052))]
+[SupportedOn(typeof(TestVolumeComponent0015))]
+        public class TestVolumeComponent0997 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(238956911);
+        }
+[SupportedOn(typeof(TestVolumeComponent0168))]
+[SupportedOn(typeof(TestVolumeComponent0151))]
+        public class TestVolumeComponent0998 : VolumeComponent
+        {
+            public IntParameter parameter = new IntParameter(1147502723);
+        }
+        public class TestVolumeComponent0999 : VolumeComponent
+        {
+            public FloatParameter parameter = new FloatParameter(971575319);
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.cs.meta
new file mode 100644
index 00000000000..afcee7311af
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f2bb8e2cf0bfbc447b8c31dae5961124
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.tt b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.tt
new file mode 100644
index 00000000000..33664641880
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.tt
@@ -0,0 +1,90 @@
+<#@ template language="C#" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+using System;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public partial class TestTypes
+    {
+        public static Type[] AllVolumeComponents = new Type[] {
+<#
+    const uint Entries = 1000;
+    for (var i = 0; i < Entries; ++i)
+    {
+#>
+            typeof(TestVolumeComponent<#= i.ToString("0000") #>),
+<#
+    }
+#>
+        };
+
+<#
+    var random = new RandomStream(652423453u, 3575452435u);
+    var allowedChars = "abcdefghijklmnopqrstuvwxzABCDEFGHIJKLMNOPQRSTUVWXYZ _/";
+    for (var i = 0u; i < 1000; ++i)
+    {
+        // Randomized uint
+        var numberOfSupportedOn = random.Next() % 3;
+
+        for (var j = 0u; j < numberOfSupportedOn; ++j)
+        {
+            var offset = random.Next() & 0xFF; // mod 256
+            var dependOnIndex = (i + offset + 1) % Entries;
+            WriteLine($"[SupportedOn(typeof(TestVolumeComponent{dependOnIndex:0000}))]");
+        }
+
+        if ((random.Next() & 0xff) < 20)
+        {
+            WriteLine("[Obsolete]");
+            WriteLine("[HideInInspector]");
+        }
+        else if ((random.Next() & 0xff) < 50)
+            WriteLine("[HideInInspector]");
+        else if ((random.Next() & 0xff) < 50)
+            WriteLine("[Obsolete]");
+
+        if ((random.Next() & 0xff) < 50)
+        {
+            var sb = new StringBuilder();
+            var c = (random.Next() & 0xff);
+            // Create a random string for the menu
+            for (var j = 0; j < c; ++j)
+            {
+                sb.Append(allowedChars[(int) (random.Next() % allowedChars.Length)]);
+            }
+            WriteLine($"[VolumeComponentMenu(\"{sb}\")]");
+        }
+#>
+        public class TestVolumeComponent<#= i.ToString("0000") #> : VolumeComponent
+        {
+<#
+        var type = (random.Next() & 1) == 1 ? "IntParameter" : "FloatParameter";
+#>
+            public <#= type #> parameter = new <#= type #>(<#= random.Next() >> 1 #>);
+        }
+<#
+    }
+#>
+    }
+}
+<#+
+    class RandomStream
+    {
+        uint m_Value;
+        uint m_Seed;
+
+        public RandomStream(uint value, uint seed)
+        {
+            m_Value = value;
+            m_Seed = seed;
+        }
+
+        public uint Next()
+        {
+            m_Value *= m_Seed;
+            m_Value ^= m_Seed;
+            return m_Value;
+        }
+    }
+#>
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.tt.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.tt.meta
new file mode 100644
index 00000000000..c69412d50ba
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/TestTypes.tt.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 388c01728c9f93e4a8c1e7809c2f480d
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeDefaultStateTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeDefaultStateTests.cs
new file mode 100644
index 00000000000..f2d64675672
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeDefaultStateTests.cs
@@ -0,0 +1,99 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public class VolumeComponentArchetypeDefaultStateTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void ReplaceDataResetStackVolumeComponents()
+        {
+            bool Property(VolumeComponentType[] types, int seed)
+            {
+                void CallOnEnable(VolumeComponent volumeComponent)
+                {
+                    volumeComponent.GetType().GetMethod("OnEnable", BindingFlags.Instance | BindingFlags.NonPublic)
+                        .Invoke(volumeComponent, Array.Empty<object>());
+                }
+
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+                if (!archetype.GetOrAddDefaultState(out var extension))
+                    return false;
+
+                var stack = VolumeStack.FromArchetype(archetype);
+
+                // Randomly change stack parameters
+                Random.InitState(seed);
+                foreach (var pair in stack.components)
+                {
+                    // Run OnEnable to make sure parameters are available
+                    CallOnEnable(pair.Value);
+
+                    foreach (var parameter in pair.Value.parameters)
+                    {
+                        parameter.overrideState = Random.value > 0.5f;
+                        switch (parameter)
+                        {
+                            case VolumeParameter<int> intParam:
+                                intParam.value = (int)(Random.value * 10000);
+                                break;
+                            case VolumeParameter<float> floatParam:
+                                floatParam.value = Random.value;
+                                break;
+                        }
+                    }
+                }
+
+                extension.ReplaceData(stack);
+                // assert the values are replaced
+                foreach (var pair in stack.components)
+                {
+                    foreach (var parameter in pair.Value.parameters)
+                    {
+                        // no parameter ar override
+                        if (parameter.overrideState)
+                            return false;
+                    }
+
+                    // Check default value
+                    var defaultInstance = (VolumeComponent)ScriptableObject.CreateInstance(pair.Value.GetType());
+                    CallOnEnable(defaultInstance);
+
+                    var c = pair.Value.parameters.Count;
+                    for (var i = 0; i < c; i++)
+                    {
+                        switch (pair.Value.parameters[i])
+                        {
+                            case VolumeParameter<int>:
+                                if (defaultInstance.parameters[i].GetValue<int>() != pair.Value.parameters[i].GetValue<int>())
+                                    return false;
+                                break;
+                            case VolumeParameter<float>:
+                                // ReSharper disable once CompareOfFloatsByEqualityOperator
+                                if (defaultInstance.parameters[i].GetValue<float>() != pair.Value.parameters[i].GetValue<float>())
+                                    return false;
+                                break;
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            Prop.ForAll<VolumeComponentType[], int>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeDefaultStateTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeDefaultStateTests.cs.meta
new file mode 100644
index 00000000000..8e357079450
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeDefaultStateTests.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 98c0633abc08405f94dc1c1eee43f8d0
+timeCreated: 1639479147
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.cs
new file mode 100644
index 00000000000..c1c3861932f
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.cs
@@ -0,0 +1,27036 @@
+using System;
+
+namespace UnityEngine.Rendering.Tests
+{
+    partial class VolumeComponentArchetypeTests
+    {
+        class GeneratedExtensions
+        {
+            public static Type[] AllTypes = new Type[]
+            {
+                typeof(VolumeArchetypeExtensionTest0000),
+                typeof(VolumeArchetypeExtensionTest0001),
+                typeof(VolumeArchetypeExtensionTest0002),
+                typeof(VolumeArchetypeExtensionTest0003),
+                typeof(VolumeArchetypeExtensionTest0004),
+                typeof(VolumeArchetypeExtensionTest0005),
+                typeof(VolumeArchetypeExtensionTest0006),
+                typeof(VolumeArchetypeExtensionTest0007),
+                typeof(VolumeArchetypeExtensionTest0008),
+                typeof(VolumeArchetypeExtensionTest0009),
+                typeof(VolumeArchetypeExtensionTest0010),
+                typeof(VolumeArchetypeExtensionTest0011),
+                typeof(VolumeArchetypeExtensionTest0012),
+                typeof(VolumeArchetypeExtensionTest0013),
+                typeof(VolumeArchetypeExtensionTest0014),
+                typeof(VolumeArchetypeExtensionTest0015),
+                typeof(VolumeArchetypeExtensionTest0016),
+                typeof(VolumeArchetypeExtensionTest0017),
+                typeof(VolumeArchetypeExtensionTest0018),
+                typeof(VolumeArchetypeExtensionTest0019),
+                typeof(VolumeArchetypeExtensionTest0020),
+                typeof(VolumeArchetypeExtensionTest0021),
+                typeof(VolumeArchetypeExtensionTest0022),
+                typeof(VolumeArchetypeExtensionTest0023),
+                typeof(VolumeArchetypeExtensionTest0024),
+                typeof(VolumeArchetypeExtensionTest0025),
+                typeof(VolumeArchetypeExtensionTest0026),
+                typeof(VolumeArchetypeExtensionTest0027),
+                typeof(VolumeArchetypeExtensionTest0028),
+                typeof(VolumeArchetypeExtensionTest0029),
+                typeof(VolumeArchetypeExtensionTest0030),
+                typeof(VolumeArchetypeExtensionTest0031),
+                typeof(VolumeArchetypeExtensionTest0032),
+                typeof(VolumeArchetypeExtensionTest0033),
+                typeof(VolumeArchetypeExtensionTest0034),
+                typeof(VolumeArchetypeExtensionTest0035),
+                typeof(VolumeArchetypeExtensionTest0036),
+                typeof(VolumeArchetypeExtensionTest0037),
+                typeof(VolumeArchetypeExtensionTest0038),
+                typeof(VolumeArchetypeExtensionTest0039),
+                typeof(VolumeArchetypeExtensionTest0040),
+                typeof(VolumeArchetypeExtensionTest0041),
+                typeof(VolumeArchetypeExtensionTest0042),
+                typeof(VolumeArchetypeExtensionTest0043),
+                typeof(VolumeArchetypeExtensionTest0044),
+                typeof(VolumeArchetypeExtensionTest0045),
+                typeof(VolumeArchetypeExtensionTest0046),
+                typeof(VolumeArchetypeExtensionTest0047),
+                typeof(VolumeArchetypeExtensionTest0048),
+                typeof(VolumeArchetypeExtensionTest0049),
+                typeof(VolumeArchetypeExtensionTest0050),
+                typeof(VolumeArchetypeExtensionTest0051),
+                typeof(VolumeArchetypeExtensionTest0052),
+                typeof(VolumeArchetypeExtensionTest0053),
+                typeof(VolumeArchetypeExtensionTest0054),
+                typeof(VolumeArchetypeExtensionTest0055),
+                typeof(VolumeArchetypeExtensionTest0056),
+                typeof(VolumeArchetypeExtensionTest0057),
+                typeof(VolumeArchetypeExtensionTest0058),
+                typeof(VolumeArchetypeExtensionTest0059),
+                typeof(VolumeArchetypeExtensionTest0060),
+                typeof(VolumeArchetypeExtensionTest0061),
+                typeof(VolumeArchetypeExtensionTest0062),
+                typeof(VolumeArchetypeExtensionTest0063),
+                typeof(VolumeArchetypeExtensionTest0064),
+                typeof(VolumeArchetypeExtensionTest0065),
+                typeof(VolumeArchetypeExtensionTest0066),
+                typeof(VolumeArchetypeExtensionTest0067),
+                typeof(VolumeArchetypeExtensionTest0068),
+                typeof(VolumeArchetypeExtensionTest0069),
+                typeof(VolumeArchetypeExtensionTest0070),
+                typeof(VolumeArchetypeExtensionTest0071),
+                typeof(VolumeArchetypeExtensionTest0072),
+                typeof(VolumeArchetypeExtensionTest0073),
+                typeof(VolumeArchetypeExtensionTest0074),
+                typeof(VolumeArchetypeExtensionTest0075),
+                typeof(VolumeArchetypeExtensionTest0076),
+                typeof(VolumeArchetypeExtensionTest0077),
+                typeof(VolumeArchetypeExtensionTest0078),
+                typeof(VolumeArchetypeExtensionTest0079),
+                typeof(VolumeArchetypeExtensionTest0080),
+                typeof(VolumeArchetypeExtensionTest0081),
+                typeof(VolumeArchetypeExtensionTest0082),
+                typeof(VolumeArchetypeExtensionTest0083),
+                typeof(VolumeArchetypeExtensionTest0084),
+                typeof(VolumeArchetypeExtensionTest0085),
+                typeof(VolumeArchetypeExtensionTest0086),
+                typeof(VolumeArchetypeExtensionTest0087),
+                typeof(VolumeArchetypeExtensionTest0088),
+                typeof(VolumeArchetypeExtensionTest0089),
+                typeof(VolumeArchetypeExtensionTest0090),
+                typeof(VolumeArchetypeExtensionTest0091),
+                typeof(VolumeArchetypeExtensionTest0092),
+                typeof(VolumeArchetypeExtensionTest0093),
+                typeof(VolumeArchetypeExtensionTest0094),
+                typeof(VolumeArchetypeExtensionTest0095),
+                typeof(VolumeArchetypeExtensionTest0096),
+                typeof(VolumeArchetypeExtensionTest0097),
+                typeof(VolumeArchetypeExtensionTest0098),
+                typeof(VolumeArchetypeExtensionTest0099),
+                typeof(VolumeArchetypeExtensionTest0100),
+                typeof(VolumeArchetypeExtensionTest0101),
+                typeof(VolumeArchetypeExtensionTest0102),
+                typeof(VolumeArchetypeExtensionTest0103),
+                typeof(VolumeArchetypeExtensionTest0104),
+                typeof(VolumeArchetypeExtensionTest0105),
+                typeof(VolumeArchetypeExtensionTest0106),
+                typeof(VolumeArchetypeExtensionTest0107),
+                typeof(VolumeArchetypeExtensionTest0108),
+                typeof(VolumeArchetypeExtensionTest0109),
+                typeof(VolumeArchetypeExtensionTest0110),
+                typeof(VolumeArchetypeExtensionTest0111),
+                typeof(VolumeArchetypeExtensionTest0112),
+                typeof(VolumeArchetypeExtensionTest0113),
+                typeof(VolumeArchetypeExtensionTest0114),
+                typeof(VolumeArchetypeExtensionTest0115),
+                typeof(VolumeArchetypeExtensionTest0116),
+                typeof(VolumeArchetypeExtensionTest0117),
+                typeof(VolumeArchetypeExtensionTest0118),
+                typeof(VolumeArchetypeExtensionTest0119),
+                typeof(VolumeArchetypeExtensionTest0120),
+                typeof(VolumeArchetypeExtensionTest0121),
+                typeof(VolumeArchetypeExtensionTest0122),
+                typeof(VolumeArchetypeExtensionTest0123),
+                typeof(VolumeArchetypeExtensionTest0124),
+                typeof(VolumeArchetypeExtensionTest0125),
+                typeof(VolumeArchetypeExtensionTest0126),
+                typeof(VolumeArchetypeExtensionTest0127),
+                typeof(VolumeArchetypeExtensionTest0128),
+                typeof(VolumeArchetypeExtensionTest0129),
+                typeof(VolumeArchetypeExtensionTest0130),
+                typeof(VolumeArchetypeExtensionTest0131),
+                typeof(VolumeArchetypeExtensionTest0132),
+                typeof(VolumeArchetypeExtensionTest0133),
+                typeof(VolumeArchetypeExtensionTest0134),
+                typeof(VolumeArchetypeExtensionTest0135),
+                typeof(VolumeArchetypeExtensionTest0136),
+                typeof(VolumeArchetypeExtensionTest0137),
+                typeof(VolumeArchetypeExtensionTest0138),
+                typeof(VolumeArchetypeExtensionTest0139),
+                typeof(VolumeArchetypeExtensionTest0140),
+                typeof(VolumeArchetypeExtensionTest0141),
+                typeof(VolumeArchetypeExtensionTest0142),
+                typeof(VolumeArchetypeExtensionTest0143),
+                typeof(VolumeArchetypeExtensionTest0144),
+                typeof(VolumeArchetypeExtensionTest0145),
+                typeof(VolumeArchetypeExtensionTest0146),
+                typeof(VolumeArchetypeExtensionTest0147),
+                typeof(VolumeArchetypeExtensionTest0148),
+                typeof(VolumeArchetypeExtensionTest0149),
+                typeof(VolumeArchetypeExtensionTest0150),
+                typeof(VolumeArchetypeExtensionTest0151),
+                typeof(VolumeArchetypeExtensionTest0152),
+                typeof(VolumeArchetypeExtensionTest0153),
+                typeof(VolumeArchetypeExtensionTest0154),
+                typeof(VolumeArchetypeExtensionTest0155),
+                typeof(VolumeArchetypeExtensionTest0156),
+                typeof(VolumeArchetypeExtensionTest0157),
+                typeof(VolumeArchetypeExtensionTest0158),
+                typeof(VolumeArchetypeExtensionTest0159),
+                typeof(VolumeArchetypeExtensionTest0160),
+                typeof(VolumeArchetypeExtensionTest0161),
+                typeof(VolumeArchetypeExtensionTest0162),
+                typeof(VolumeArchetypeExtensionTest0163),
+                typeof(VolumeArchetypeExtensionTest0164),
+                typeof(VolumeArchetypeExtensionTest0165),
+                typeof(VolumeArchetypeExtensionTest0166),
+                typeof(VolumeArchetypeExtensionTest0167),
+                typeof(VolumeArchetypeExtensionTest0168),
+                typeof(VolumeArchetypeExtensionTest0169),
+                typeof(VolumeArchetypeExtensionTest0170),
+                typeof(VolumeArchetypeExtensionTest0171),
+                typeof(VolumeArchetypeExtensionTest0172),
+                typeof(VolumeArchetypeExtensionTest0173),
+                typeof(VolumeArchetypeExtensionTest0174),
+                typeof(VolumeArchetypeExtensionTest0175),
+                typeof(VolumeArchetypeExtensionTest0176),
+                typeof(VolumeArchetypeExtensionTest0177),
+                typeof(VolumeArchetypeExtensionTest0178),
+                typeof(VolumeArchetypeExtensionTest0179),
+                typeof(VolumeArchetypeExtensionTest0180),
+                typeof(VolumeArchetypeExtensionTest0181),
+                typeof(VolumeArchetypeExtensionTest0182),
+                typeof(VolumeArchetypeExtensionTest0183),
+                typeof(VolumeArchetypeExtensionTest0184),
+                typeof(VolumeArchetypeExtensionTest0185),
+                typeof(VolumeArchetypeExtensionTest0186),
+                typeof(VolumeArchetypeExtensionTest0187),
+                typeof(VolumeArchetypeExtensionTest0188),
+                typeof(VolumeArchetypeExtensionTest0189),
+                typeof(VolumeArchetypeExtensionTest0190),
+                typeof(VolumeArchetypeExtensionTest0191),
+                typeof(VolumeArchetypeExtensionTest0192),
+                typeof(VolumeArchetypeExtensionTest0193),
+                typeof(VolumeArchetypeExtensionTest0194),
+                typeof(VolumeArchetypeExtensionTest0195),
+                typeof(VolumeArchetypeExtensionTest0196),
+                typeof(VolumeArchetypeExtensionTest0197),
+                typeof(VolumeArchetypeExtensionTest0198),
+                typeof(VolumeArchetypeExtensionTest0199),
+                typeof(VolumeArchetypeExtensionTest0200),
+                typeof(VolumeArchetypeExtensionTest0201),
+                typeof(VolumeArchetypeExtensionTest0202),
+                typeof(VolumeArchetypeExtensionTest0203),
+                typeof(VolumeArchetypeExtensionTest0204),
+                typeof(VolumeArchetypeExtensionTest0205),
+                typeof(VolumeArchetypeExtensionTest0206),
+                typeof(VolumeArchetypeExtensionTest0207),
+                typeof(VolumeArchetypeExtensionTest0208),
+                typeof(VolumeArchetypeExtensionTest0209),
+                typeof(VolumeArchetypeExtensionTest0210),
+                typeof(VolumeArchetypeExtensionTest0211),
+                typeof(VolumeArchetypeExtensionTest0212),
+                typeof(VolumeArchetypeExtensionTest0213),
+                typeof(VolumeArchetypeExtensionTest0214),
+                typeof(VolumeArchetypeExtensionTest0215),
+                typeof(VolumeArchetypeExtensionTest0216),
+                typeof(VolumeArchetypeExtensionTest0217),
+                typeof(VolumeArchetypeExtensionTest0218),
+                typeof(VolumeArchetypeExtensionTest0219),
+                typeof(VolumeArchetypeExtensionTest0220),
+                typeof(VolumeArchetypeExtensionTest0221),
+                typeof(VolumeArchetypeExtensionTest0222),
+                typeof(VolumeArchetypeExtensionTest0223),
+                typeof(VolumeArchetypeExtensionTest0224),
+                typeof(VolumeArchetypeExtensionTest0225),
+                typeof(VolumeArchetypeExtensionTest0226),
+                typeof(VolumeArchetypeExtensionTest0227),
+                typeof(VolumeArchetypeExtensionTest0228),
+                typeof(VolumeArchetypeExtensionTest0229),
+                typeof(VolumeArchetypeExtensionTest0230),
+                typeof(VolumeArchetypeExtensionTest0231),
+                typeof(VolumeArchetypeExtensionTest0232),
+                typeof(VolumeArchetypeExtensionTest0233),
+                typeof(VolumeArchetypeExtensionTest0234),
+                typeof(VolumeArchetypeExtensionTest0235),
+                typeof(VolumeArchetypeExtensionTest0236),
+                typeof(VolumeArchetypeExtensionTest0237),
+                typeof(VolumeArchetypeExtensionTest0238),
+                typeof(VolumeArchetypeExtensionTest0239),
+                typeof(VolumeArchetypeExtensionTest0240),
+                typeof(VolumeArchetypeExtensionTest0241),
+                typeof(VolumeArchetypeExtensionTest0242),
+                typeof(VolumeArchetypeExtensionTest0243),
+                typeof(VolumeArchetypeExtensionTest0244),
+                typeof(VolumeArchetypeExtensionTest0245),
+                typeof(VolumeArchetypeExtensionTest0246),
+                typeof(VolumeArchetypeExtensionTest0247),
+                typeof(VolumeArchetypeExtensionTest0248),
+                typeof(VolumeArchetypeExtensionTest0249),
+                typeof(VolumeArchetypeExtensionTest0250),
+                typeof(VolumeArchetypeExtensionTest0251),
+                typeof(VolumeArchetypeExtensionTest0252),
+                typeof(VolumeArchetypeExtensionTest0253),
+                typeof(VolumeArchetypeExtensionTest0254),
+                typeof(VolumeArchetypeExtensionTest0255),
+                typeof(VolumeArchetypeExtensionTest0256),
+                typeof(VolumeArchetypeExtensionTest0257),
+                typeof(VolumeArchetypeExtensionTest0258),
+                typeof(VolumeArchetypeExtensionTest0259),
+                typeof(VolumeArchetypeExtensionTest0260),
+                typeof(VolumeArchetypeExtensionTest0261),
+                typeof(VolumeArchetypeExtensionTest0262),
+                typeof(VolumeArchetypeExtensionTest0263),
+                typeof(VolumeArchetypeExtensionTest0264),
+                typeof(VolumeArchetypeExtensionTest0265),
+                typeof(VolumeArchetypeExtensionTest0266),
+                typeof(VolumeArchetypeExtensionTest0267),
+                typeof(VolumeArchetypeExtensionTest0268),
+                typeof(VolumeArchetypeExtensionTest0269),
+                typeof(VolumeArchetypeExtensionTest0270),
+                typeof(VolumeArchetypeExtensionTest0271),
+                typeof(VolumeArchetypeExtensionTest0272),
+                typeof(VolumeArchetypeExtensionTest0273),
+                typeof(VolumeArchetypeExtensionTest0274),
+                typeof(VolumeArchetypeExtensionTest0275),
+                typeof(VolumeArchetypeExtensionTest0276),
+                typeof(VolumeArchetypeExtensionTest0277),
+                typeof(VolumeArchetypeExtensionTest0278),
+                typeof(VolumeArchetypeExtensionTest0279),
+                typeof(VolumeArchetypeExtensionTest0280),
+                typeof(VolumeArchetypeExtensionTest0281),
+                typeof(VolumeArchetypeExtensionTest0282),
+                typeof(VolumeArchetypeExtensionTest0283),
+                typeof(VolumeArchetypeExtensionTest0284),
+                typeof(VolumeArchetypeExtensionTest0285),
+                typeof(VolumeArchetypeExtensionTest0286),
+                typeof(VolumeArchetypeExtensionTest0287),
+                typeof(VolumeArchetypeExtensionTest0288),
+                typeof(VolumeArchetypeExtensionTest0289),
+                typeof(VolumeArchetypeExtensionTest0290),
+                typeof(VolumeArchetypeExtensionTest0291),
+                typeof(VolumeArchetypeExtensionTest0292),
+                typeof(VolumeArchetypeExtensionTest0293),
+                typeof(VolumeArchetypeExtensionTest0294),
+                typeof(VolumeArchetypeExtensionTest0295),
+                typeof(VolumeArchetypeExtensionTest0296),
+                typeof(VolumeArchetypeExtensionTest0297),
+                typeof(VolumeArchetypeExtensionTest0298),
+                typeof(VolumeArchetypeExtensionTest0299),
+                typeof(VolumeArchetypeExtensionTest0300),
+                typeof(VolumeArchetypeExtensionTest0301),
+                typeof(VolumeArchetypeExtensionTest0302),
+                typeof(VolumeArchetypeExtensionTest0303),
+                typeof(VolumeArchetypeExtensionTest0304),
+                typeof(VolumeArchetypeExtensionTest0305),
+                typeof(VolumeArchetypeExtensionTest0306),
+                typeof(VolumeArchetypeExtensionTest0307),
+                typeof(VolumeArchetypeExtensionTest0308),
+                typeof(VolumeArchetypeExtensionTest0309),
+                typeof(VolumeArchetypeExtensionTest0310),
+                typeof(VolumeArchetypeExtensionTest0311),
+                typeof(VolumeArchetypeExtensionTest0312),
+                typeof(VolumeArchetypeExtensionTest0313),
+                typeof(VolumeArchetypeExtensionTest0314),
+                typeof(VolumeArchetypeExtensionTest0315),
+                typeof(VolumeArchetypeExtensionTest0316),
+                typeof(VolumeArchetypeExtensionTest0317),
+                typeof(VolumeArchetypeExtensionTest0318),
+                typeof(VolumeArchetypeExtensionTest0319),
+                typeof(VolumeArchetypeExtensionTest0320),
+                typeof(VolumeArchetypeExtensionTest0321),
+                typeof(VolumeArchetypeExtensionTest0322),
+                typeof(VolumeArchetypeExtensionTest0323),
+                typeof(VolumeArchetypeExtensionTest0324),
+                typeof(VolumeArchetypeExtensionTest0325),
+                typeof(VolumeArchetypeExtensionTest0326),
+                typeof(VolumeArchetypeExtensionTest0327),
+                typeof(VolumeArchetypeExtensionTest0328),
+                typeof(VolumeArchetypeExtensionTest0329),
+                typeof(VolumeArchetypeExtensionTest0330),
+                typeof(VolumeArchetypeExtensionTest0331),
+                typeof(VolumeArchetypeExtensionTest0332),
+                typeof(VolumeArchetypeExtensionTest0333),
+                typeof(VolumeArchetypeExtensionTest0334),
+                typeof(VolumeArchetypeExtensionTest0335),
+                typeof(VolumeArchetypeExtensionTest0336),
+                typeof(VolumeArchetypeExtensionTest0337),
+                typeof(VolumeArchetypeExtensionTest0338),
+                typeof(VolumeArchetypeExtensionTest0339),
+                typeof(VolumeArchetypeExtensionTest0340),
+                typeof(VolumeArchetypeExtensionTest0341),
+                typeof(VolumeArchetypeExtensionTest0342),
+                typeof(VolumeArchetypeExtensionTest0343),
+                typeof(VolumeArchetypeExtensionTest0344),
+                typeof(VolumeArchetypeExtensionTest0345),
+                typeof(VolumeArchetypeExtensionTest0346),
+                typeof(VolumeArchetypeExtensionTest0347),
+                typeof(VolumeArchetypeExtensionTest0348),
+                typeof(VolumeArchetypeExtensionTest0349),
+                typeof(VolumeArchetypeExtensionTest0350),
+                typeof(VolumeArchetypeExtensionTest0351),
+                typeof(VolumeArchetypeExtensionTest0352),
+                typeof(VolumeArchetypeExtensionTest0353),
+                typeof(VolumeArchetypeExtensionTest0354),
+                typeof(VolumeArchetypeExtensionTest0355),
+                typeof(VolumeArchetypeExtensionTest0356),
+                typeof(VolumeArchetypeExtensionTest0357),
+                typeof(VolumeArchetypeExtensionTest0358),
+                typeof(VolumeArchetypeExtensionTest0359),
+                typeof(VolumeArchetypeExtensionTest0360),
+                typeof(VolumeArchetypeExtensionTest0361),
+                typeof(VolumeArchetypeExtensionTest0362),
+                typeof(VolumeArchetypeExtensionTest0363),
+                typeof(VolumeArchetypeExtensionTest0364),
+                typeof(VolumeArchetypeExtensionTest0365),
+                typeof(VolumeArchetypeExtensionTest0366),
+                typeof(VolumeArchetypeExtensionTest0367),
+                typeof(VolumeArchetypeExtensionTest0368),
+                typeof(VolumeArchetypeExtensionTest0369),
+                typeof(VolumeArchetypeExtensionTest0370),
+                typeof(VolumeArchetypeExtensionTest0371),
+                typeof(VolumeArchetypeExtensionTest0372),
+                typeof(VolumeArchetypeExtensionTest0373),
+                typeof(VolumeArchetypeExtensionTest0374),
+                typeof(VolumeArchetypeExtensionTest0375),
+                typeof(VolumeArchetypeExtensionTest0376),
+                typeof(VolumeArchetypeExtensionTest0377),
+                typeof(VolumeArchetypeExtensionTest0378),
+                typeof(VolumeArchetypeExtensionTest0379),
+                typeof(VolumeArchetypeExtensionTest0380),
+                typeof(VolumeArchetypeExtensionTest0381),
+                typeof(VolumeArchetypeExtensionTest0382),
+                typeof(VolumeArchetypeExtensionTest0383),
+                typeof(VolumeArchetypeExtensionTest0384),
+                typeof(VolumeArchetypeExtensionTest0385),
+                typeof(VolumeArchetypeExtensionTest0386),
+                typeof(VolumeArchetypeExtensionTest0387),
+                typeof(VolumeArchetypeExtensionTest0388),
+                typeof(VolumeArchetypeExtensionTest0389),
+                typeof(VolumeArchetypeExtensionTest0390),
+                typeof(VolumeArchetypeExtensionTest0391),
+                typeof(VolumeArchetypeExtensionTest0392),
+                typeof(VolumeArchetypeExtensionTest0393),
+                typeof(VolumeArchetypeExtensionTest0394),
+                typeof(VolumeArchetypeExtensionTest0395),
+                typeof(VolumeArchetypeExtensionTest0396),
+                typeof(VolumeArchetypeExtensionTest0397),
+                typeof(VolumeArchetypeExtensionTest0398),
+                typeof(VolumeArchetypeExtensionTest0399),
+                typeof(VolumeArchetypeExtensionTest0400),
+                typeof(VolumeArchetypeExtensionTest0401),
+                typeof(VolumeArchetypeExtensionTest0402),
+                typeof(VolumeArchetypeExtensionTest0403),
+                typeof(VolumeArchetypeExtensionTest0404),
+                typeof(VolumeArchetypeExtensionTest0405),
+                typeof(VolumeArchetypeExtensionTest0406),
+                typeof(VolumeArchetypeExtensionTest0407),
+                typeof(VolumeArchetypeExtensionTest0408),
+                typeof(VolumeArchetypeExtensionTest0409),
+                typeof(VolumeArchetypeExtensionTest0410),
+                typeof(VolumeArchetypeExtensionTest0411),
+                typeof(VolumeArchetypeExtensionTest0412),
+                typeof(VolumeArchetypeExtensionTest0413),
+                typeof(VolumeArchetypeExtensionTest0414),
+                typeof(VolumeArchetypeExtensionTest0415),
+                typeof(VolumeArchetypeExtensionTest0416),
+                typeof(VolumeArchetypeExtensionTest0417),
+                typeof(VolumeArchetypeExtensionTest0418),
+                typeof(VolumeArchetypeExtensionTest0419),
+                typeof(VolumeArchetypeExtensionTest0420),
+                typeof(VolumeArchetypeExtensionTest0421),
+                typeof(VolumeArchetypeExtensionTest0422),
+                typeof(VolumeArchetypeExtensionTest0423),
+                typeof(VolumeArchetypeExtensionTest0424),
+                typeof(VolumeArchetypeExtensionTest0425),
+                typeof(VolumeArchetypeExtensionTest0426),
+                typeof(VolumeArchetypeExtensionTest0427),
+                typeof(VolumeArchetypeExtensionTest0428),
+                typeof(VolumeArchetypeExtensionTest0429),
+                typeof(VolumeArchetypeExtensionTest0430),
+                typeof(VolumeArchetypeExtensionTest0431),
+                typeof(VolumeArchetypeExtensionTest0432),
+                typeof(VolumeArchetypeExtensionTest0433),
+                typeof(VolumeArchetypeExtensionTest0434),
+                typeof(VolumeArchetypeExtensionTest0435),
+                typeof(VolumeArchetypeExtensionTest0436),
+                typeof(VolumeArchetypeExtensionTest0437),
+                typeof(VolumeArchetypeExtensionTest0438),
+                typeof(VolumeArchetypeExtensionTest0439),
+                typeof(VolumeArchetypeExtensionTest0440),
+                typeof(VolumeArchetypeExtensionTest0441),
+                typeof(VolumeArchetypeExtensionTest0442),
+                typeof(VolumeArchetypeExtensionTest0443),
+                typeof(VolumeArchetypeExtensionTest0444),
+                typeof(VolumeArchetypeExtensionTest0445),
+                typeof(VolumeArchetypeExtensionTest0446),
+                typeof(VolumeArchetypeExtensionTest0447),
+                typeof(VolumeArchetypeExtensionTest0448),
+                typeof(VolumeArchetypeExtensionTest0449),
+                typeof(VolumeArchetypeExtensionTest0450),
+                typeof(VolumeArchetypeExtensionTest0451),
+                typeof(VolumeArchetypeExtensionTest0452),
+                typeof(VolumeArchetypeExtensionTest0453),
+                typeof(VolumeArchetypeExtensionTest0454),
+                typeof(VolumeArchetypeExtensionTest0455),
+                typeof(VolumeArchetypeExtensionTest0456),
+                typeof(VolumeArchetypeExtensionTest0457),
+                typeof(VolumeArchetypeExtensionTest0458),
+                typeof(VolumeArchetypeExtensionTest0459),
+                typeof(VolumeArchetypeExtensionTest0460),
+                typeof(VolumeArchetypeExtensionTest0461),
+                typeof(VolumeArchetypeExtensionTest0462),
+                typeof(VolumeArchetypeExtensionTest0463),
+                typeof(VolumeArchetypeExtensionTest0464),
+                typeof(VolumeArchetypeExtensionTest0465),
+                typeof(VolumeArchetypeExtensionTest0466),
+                typeof(VolumeArchetypeExtensionTest0467),
+                typeof(VolumeArchetypeExtensionTest0468),
+                typeof(VolumeArchetypeExtensionTest0469),
+                typeof(VolumeArchetypeExtensionTest0470),
+                typeof(VolumeArchetypeExtensionTest0471),
+                typeof(VolumeArchetypeExtensionTest0472),
+                typeof(VolumeArchetypeExtensionTest0473),
+                typeof(VolumeArchetypeExtensionTest0474),
+                typeof(VolumeArchetypeExtensionTest0475),
+                typeof(VolumeArchetypeExtensionTest0476),
+                typeof(VolumeArchetypeExtensionTest0477),
+                typeof(VolumeArchetypeExtensionTest0478),
+                typeof(VolumeArchetypeExtensionTest0479),
+                typeof(VolumeArchetypeExtensionTest0480),
+                typeof(VolumeArchetypeExtensionTest0481),
+                typeof(VolumeArchetypeExtensionTest0482),
+                typeof(VolumeArchetypeExtensionTest0483),
+                typeof(VolumeArchetypeExtensionTest0484),
+                typeof(VolumeArchetypeExtensionTest0485),
+                typeof(VolumeArchetypeExtensionTest0486),
+                typeof(VolumeArchetypeExtensionTest0487),
+                typeof(VolumeArchetypeExtensionTest0488),
+                typeof(VolumeArchetypeExtensionTest0489),
+                typeof(VolumeArchetypeExtensionTest0490),
+                typeof(VolumeArchetypeExtensionTest0491),
+                typeof(VolumeArchetypeExtensionTest0492),
+                typeof(VolumeArchetypeExtensionTest0493),
+                typeof(VolumeArchetypeExtensionTest0494),
+                typeof(VolumeArchetypeExtensionTest0495),
+                typeof(VolumeArchetypeExtensionTest0496),
+                typeof(VolumeArchetypeExtensionTest0497),
+                typeof(VolumeArchetypeExtensionTest0498),
+                typeof(VolumeArchetypeExtensionTest0499),
+                typeof(VolumeArchetypeExtensionTest0500),
+                typeof(VolumeArchetypeExtensionTest0501),
+                typeof(VolumeArchetypeExtensionTest0502),
+                typeof(VolumeArchetypeExtensionTest0503),
+                typeof(VolumeArchetypeExtensionTest0504),
+                typeof(VolumeArchetypeExtensionTest0505),
+                typeof(VolumeArchetypeExtensionTest0506),
+                typeof(VolumeArchetypeExtensionTest0507),
+                typeof(VolumeArchetypeExtensionTest0508),
+                typeof(VolumeArchetypeExtensionTest0509),
+                typeof(VolumeArchetypeExtensionTest0510),
+                typeof(VolumeArchetypeExtensionTest0511),
+                typeof(VolumeArchetypeExtensionTest0512),
+                typeof(VolumeArchetypeExtensionTest0513),
+                typeof(VolumeArchetypeExtensionTest0514),
+                typeof(VolumeArchetypeExtensionTest0515),
+                typeof(VolumeArchetypeExtensionTest0516),
+                typeof(VolumeArchetypeExtensionTest0517),
+                typeof(VolumeArchetypeExtensionTest0518),
+                typeof(VolumeArchetypeExtensionTest0519),
+                typeof(VolumeArchetypeExtensionTest0520),
+                typeof(VolumeArchetypeExtensionTest0521),
+                typeof(VolumeArchetypeExtensionTest0522),
+                typeof(VolumeArchetypeExtensionTest0523),
+                typeof(VolumeArchetypeExtensionTest0524),
+                typeof(VolumeArchetypeExtensionTest0525),
+                typeof(VolumeArchetypeExtensionTest0526),
+                typeof(VolumeArchetypeExtensionTest0527),
+                typeof(VolumeArchetypeExtensionTest0528),
+                typeof(VolumeArchetypeExtensionTest0529),
+                typeof(VolumeArchetypeExtensionTest0530),
+                typeof(VolumeArchetypeExtensionTest0531),
+                typeof(VolumeArchetypeExtensionTest0532),
+                typeof(VolumeArchetypeExtensionTest0533),
+                typeof(VolumeArchetypeExtensionTest0534),
+                typeof(VolumeArchetypeExtensionTest0535),
+                typeof(VolumeArchetypeExtensionTest0536),
+                typeof(VolumeArchetypeExtensionTest0537),
+                typeof(VolumeArchetypeExtensionTest0538),
+                typeof(VolumeArchetypeExtensionTest0539),
+                typeof(VolumeArchetypeExtensionTest0540),
+                typeof(VolumeArchetypeExtensionTest0541),
+                typeof(VolumeArchetypeExtensionTest0542),
+                typeof(VolumeArchetypeExtensionTest0543),
+                typeof(VolumeArchetypeExtensionTest0544),
+                typeof(VolumeArchetypeExtensionTest0545),
+                typeof(VolumeArchetypeExtensionTest0546),
+                typeof(VolumeArchetypeExtensionTest0547),
+                typeof(VolumeArchetypeExtensionTest0548),
+                typeof(VolumeArchetypeExtensionTest0549),
+                typeof(VolumeArchetypeExtensionTest0550),
+                typeof(VolumeArchetypeExtensionTest0551),
+                typeof(VolumeArchetypeExtensionTest0552),
+                typeof(VolumeArchetypeExtensionTest0553),
+                typeof(VolumeArchetypeExtensionTest0554),
+                typeof(VolumeArchetypeExtensionTest0555),
+                typeof(VolumeArchetypeExtensionTest0556),
+                typeof(VolumeArchetypeExtensionTest0557),
+                typeof(VolumeArchetypeExtensionTest0558),
+                typeof(VolumeArchetypeExtensionTest0559),
+                typeof(VolumeArchetypeExtensionTest0560),
+                typeof(VolumeArchetypeExtensionTest0561),
+                typeof(VolumeArchetypeExtensionTest0562),
+                typeof(VolumeArchetypeExtensionTest0563),
+                typeof(VolumeArchetypeExtensionTest0564),
+                typeof(VolumeArchetypeExtensionTest0565),
+                typeof(VolumeArchetypeExtensionTest0566),
+                typeof(VolumeArchetypeExtensionTest0567),
+                typeof(VolumeArchetypeExtensionTest0568),
+                typeof(VolumeArchetypeExtensionTest0569),
+                typeof(VolumeArchetypeExtensionTest0570),
+                typeof(VolumeArchetypeExtensionTest0571),
+                typeof(VolumeArchetypeExtensionTest0572),
+                typeof(VolumeArchetypeExtensionTest0573),
+                typeof(VolumeArchetypeExtensionTest0574),
+                typeof(VolumeArchetypeExtensionTest0575),
+                typeof(VolumeArchetypeExtensionTest0576),
+                typeof(VolumeArchetypeExtensionTest0577),
+                typeof(VolumeArchetypeExtensionTest0578),
+                typeof(VolumeArchetypeExtensionTest0579),
+                typeof(VolumeArchetypeExtensionTest0580),
+                typeof(VolumeArchetypeExtensionTest0581),
+                typeof(VolumeArchetypeExtensionTest0582),
+                typeof(VolumeArchetypeExtensionTest0583),
+                typeof(VolumeArchetypeExtensionTest0584),
+                typeof(VolumeArchetypeExtensionTest0585),
+                typeof(VolumeArchetypeExtensionTest0586),
+                typeof(VolumeArchetypeExtensionTest0587),
+                typeof(VolumeArchetypeExtensionTest0588),
+                typeof(VolumeArchetypeExtensionTest0589),
+                typeof(VolumeArchetypeExtensionTest0590),
+                typeof(VolumeArchetypeExtensionTest0591),
+                typeof(VolumeArchetypeExtensionTest0592),
+                typeof(VolumeArchetypeExtensionTest0593),
+                typeof(VolumeArchetypeExtensionTest0594),
+                typeof(VolumeArchetypeExtensionTest0595),
+                typeof(VolumeArchetypeExtensionTest0596),
+                typeof(VolumeArchetypeExtensionTest0597),
+                typeof(VolumeArchetypeExtensionTest0598),
+                typeof(VolumeArchetypeExtensionTest0599),
+                typeof(VolumeArchetypeExtensionTest0600),
+                typeof(VolumeArchetypeExtensionTest0601),
+                typeof(VolumeArchetypeExtensionTest0602),
+                typeof(VolumeArchetypeExtensionTest0603),
+                typeof(VolumeArchetypeExtensionTest0604),
+                typeof(VolumeArchetypeExtensionTest0605),
+                typeof(VolumeArchetypeExtensionTest0606),
+                typeof(VolumeArchetypeExtensionTest0607),
+                typeof(VolumeArchetypeExtensionTest0608),
+                typeof(VolumeArchetypeExtensionTest0609),
+                typeof(VolumeArchetypeExtensionTest0610),
+                typeof(VolumeArchetypeExtensionTest0611),
+                typeof(VolumeArchetypeExtensionTest0612),
+                typeof(VolumeArchetypeExtensionTest0613),
+                typeof(VolumeArchetypeExtensionTest0614),
+                typeof(VolumeArchetypeExtensionTest0615),
+                typeof(VolumeArchetypeExtensionTest0616),
+                typeof(VolumeArchetypeExtensionTest0617),
+                typeof(VolumeArchetypeExtensionTest0618),
+                typeof(VolumeArchetypeExtensionTest0619),
+                typeof(VolumeArchetypeExtensionTest0620),
+                typeof(VolumeArchetypeExtensionTest0621),
+                typeof(VolumeArchetypeExtensionTest0622),
+                typeof(VolumeArchetypeExtensionTest0623),
+                typeof(VolumeArchetypeExtensionTest0624),
+                typeof(VolumeArchetypeExtensionTest0625),
+                typeof(VolumeArchetypeExtensionTest0626),
+                typeof(VolumeArchetypeExtensionTest0627),
+                typeof(VolumeArchetypeExtensionTest0628),
+                typeof(VolumeArchetypeExtensionTest0629),
+                typeof(VolumeArchetypeExtensionTest0630),
+                typeof(VolumeArchetypeExtensionTest0631),
+                typeof(VolumeArchetypeExtensionTest0632),
+                typeof(VolumeArchetypeExtensionTest0633),
+                typeof(VolumeArchetypeExtensionTest0634),
+                typeof(VolumeArchetypeExtensionTest0635),
+                typeof(VolumeArchetypeExtensionTest0636),
+                typeof(VolumeArchetypeExtensionTest0637),
+                typeof(VolumeArchetypeExtensionTest0638),
+                typeof(VolumeArchetypeExtensionTest0639),
+                typeof(VolumeArchetypeExtensionTest0640),
+                typeof(VolumeArchetypeExtensionTest0641),
+                typeof(VolumeArchetypeExtensionTest0642),
+                typeof(VolumeArchetypeExtensionTest0643),
+                typeof(VolumeArchetypeExtensionTest0644),
+                typeof(VolumeArchetypeExtensionTest0645),
+                typeof(VolumeArchetypeExtensionTest0646),
+                typeof(VolumeArchetypeExtensionTest0647),
+                typeof(VolumeArchetypeExtensionTest0648),
+                typeof(VolumeArchetypeExtensionTest0649),
+                typeof(VolumeArchetypeExtensionTest0650),
+                typeof(VolumeArchetypeExtensionTest0651),
+                typeof(VolumeArchetypeExtensionTest0652),
+                typeof(VolumeArchetypeExtensionTest0653),
+                typeof(VolumeArchetypeExtensionTest0654),
+                typeof(VolumeArchetypeExtensionTest0655),
+                typeof(VolumeArchetypeExtensionTest0656),
+                typeof(VolumeArchetypeExtensionTest0657),
+                typeof(VolumeArchetypeExtensionTest0658),
+                typeof(VolumeArchetypeExtensionTest0659),
+                typeof(VolumeArchetypeExtensionTest0660),
+                typeof(VolumeArchetypeExtensionTest0661),
+                typeof(VolumeArchetypeExtensionTest0662),
+                typeof(VolumeArchetypeExtensionTest0663),
+                typeof(VolumeArchetypeExtensionTest0664),
+                typeof(VolumeArchetypeExtensionTest0665),
+                typeof(VolumeArchetypeExtensionTest0666),
+                typeof(VolumeArchetypeExtensionTest0667),
+                typeof(VolumeArchetypeExtensionTest0668),
+                typeof(VolumeArchetypeExtensionTest0669),
+                typeof(VolumeArchetypeExtensionTest0670),
+                typeof(VolumeArchetypeExtensionTest0671),
+                typeof(VolumeArchetypeExtensionTest0672),
+                typeof(VolumeArchetypeExtensionTest0673),
+                typeof(VolumeArchetypeExtensionTest0674),
+                typeof(VolumeArchetypeExtensionTest0675),
+                typeof(VolumeArchetypeExtensionTest0676),
+                typeof(VolumeArchetypeExtensionTest0677),
+                typeof(VolumeArchetypeExtensionTest0678),
+                typeof(VolumeArchetypeExtensionTest0679),
+                typeof(VolumeArchetypeExtensionTest0680),
+                typeof(VolumeArchetypeExtensionTest0681),
+                typeof(VolumeArchetypeExtensionTest0682),
+                typeof(VolumeArchetypeExtensionTest0683),
+                typeof(VolumeArchetypeExtensionTest0684),
+                typeof(VolumeArchetypeExtensionTest0685),
+                typeof(VolumeArchetypeExtensionTest0686),
+                typeof(VolumeArchetypeExtensionTest0687),
+                typeof(VolumeArchetypeExtensionTest0688),
+                typeof(VolumeArchetypeExtensionTest0689),
+                typeof(VolumeArchetypeExtensionTest0690),
+                typeof(VolumeArchetypeExtensionTest0691),
+                typeof(VolumeArchetypeExtensionTest0692),
+                typeof(VolumeArchetypeExtensionTest0693),
+                typeof(VolumeArchetypeExtensionTest0694),
+                typeof(VolumeArchetypeExtensionTest0695),
+                typeof(VolumeArchetypeExtensionTest0696),
+                typeof(VolumeArchetypeExtensionTest0697),
+                typeof(VolumeArchetypeExtensionTest0698),
+                typeof(VolumeArchetypeExtensionTest0699),
+                typeof(VolumeArchetypeExtensionTest0700),
+                typeof(VolumeArchetypeExtensionTest0701),
+                typeof(VolumeArchetypeExtensionTest0702),
+                typeof(VolumeArchetypeExtensionTest0703),
+                typeof(VolumeArchetypeExtensionTest0704),
+                typeof(VolumeArchetypeExtensionTest0705),
+                typeof(VolumeArchetypeExtensionTest0706),
+                typeof(VolumeArchetypeExtensionTest0707),
+                typeof(VolumeArchetypeExtensionTest0708),
+                typeof(VolumeArchetypeExtensionTest0709),
+                typeof(VolumeArchetypeExtensionTest0710),
+                typeof(VolumeArchetypeExtensionTest0711),
+                typeof(VolumeArchetypeExtensionTest0712),
+                typeof(VolumeArchetypeExtensionTest0713),
+                typeof(VolumeArchetypeExtensionTest0714),
+                typeof(VolumeArchetypeExtensionTest0715),
+                typeof(VolumeArchetypeExtensionTest0716),
+                typeof(VolumeArchetypeExtensionTest0717),
+                typeof(VolumeArchetypeExtensionTest0718),
+                typeof(VolumeArchetypeExtensionTest0719),
+                typeof(VolumeArchetypeExtensionTest0720),
+                typeof(VolumeArchetypeExtensionTest0721),
+                typeof(VolumeArchetypeExtensionTest0722),
+                typeof(VolumeArchetypeExtensionTest0723),
+                typeof(VolumeArchetypeExtensionTest0724),
+                typeof(VolumeArchetypeExtensionTest0725),
+                typeof(VolumeArchetypeExtensionTest0726),
+                typeof(VolumeArchetypeExtensionTest0727),
+                typeof(VolumeArchetypeExtensionTest0728),
+                typeof(VolumeArchetypeExtensionTest0729),
+                typeof(VolumeArchetypeExtensionTest0730),
+                typeof(VolumeArchetypeExtensionTest0731),
+                typeof(VolumeArchetypeExtensionTest0732),
+                typeof(VolumeArchetypeExtensionTest0733),
+                typeof(VolumeArchetypeExtensionTest0734),
+                typeof(VolumeArchetypeExtensionTest0735),
+                typeof(VolumeArchetypeExtensionTest0736),
+                typeof(VolumeArchetypeExtensionTest0737),
+                typeof(VolumeArchetypeExtensionTest0738),
+                typeof(VolumeArchetypeExtensionTest0739),
+                typeof(VolumeArchetypeExtensionTest0740),
+                typeof(VolumeArchetypeExtensionTest0741),
+                typeof(VolumeArchetypeExtensionTest0742),
+                typeof(VolumeArchetypeExtensionTest0743),
+                typeof(VolumeArchetypeExtensionTest0744),
+                typeof(VolumeArchetypeExtensionTest0745),
+                typeof(VolumeArchetypeExtensionTest0746),
+                typeof(VolumeArchetypeExtensionTest0747),
+                typeof(VolumeArchetypeExtensionTest0748),
+                typeof(VolumeArchetypeExtensionTest0749),
+                typeof(VolumeArchetypeExtensionTest0750),
+                typeof(VolumeArchetypeExtensionTest0751),
+                typeof(VolumeArchetypeExtensionTest0752),
+                typeof(VolumeArchetypeExtensionTest0753),
+                typeof(VolumeArchetypeExtensionTest0754),
+                typeof(VolumeArchetypeExtensionTest0755),
+                typeof(VolumeArchetypeExtensionTest0756),
+                typeof(VolumeArchetypeExtensionTest0757),
+                typeof(VolumeArchetypeExtensionTest0758),
+                typeof(VolumeArchetypeExtensionTest0759),
+                typeof(VolumeArchetypeExtensionTest0760),
+                typeof(VolumeArchetypeExtensionTest0761),
+                typeof(VolumeArchetypeExtensionTest0762),
+                typeof(VolumeArchetypeExtensionTest0763),
+                typeof(VolumeArchetypeExtensionTest0764),
+                typeof(VolumeArchetypeExtensionTest0765),
+                typeof(VolumeArchetypeExtensionTest0766),
+                typeof(VolumeArchetypeExtensionTest0767),
+                typeof(VolumeArchetypeExtensionTest0768),
+                typeof(VolumeArchetypeExtensionTest0769),
+                typeof(VolumeArchetypeExtensionTest0770),
+                typeof(VolumeArchetypeExtensionTest0771),
+                typeof(VolumeArchetypeExtensionTest0772),
+                typeof(VolumeArchetypeExtensionTest0773),
+                typeof(VolumeArchetypeExtensionTest0774),
+                typeof(VolumeArchetypeExtensionTest0775),
+                typeof(VolumeArchetypeExtensionTest0776),
+                typeof(VolumeArchetypeExtensionTest0777),
+                typeof(VolumeArchetypeExtensionTest0778),
+                typeof(VolumeArchetypeExtensionTest0779),
+                typeof(VolumeArchetypeExtensionTest0780),
+                typeof(VolumeArchetypeExtensionTest0781),
+                typeof(VolumeArchetypeExtensionTest0782),
+                typeof(VolumeArchetypeExtensionTest0783),
+                typeof(VolumeArchetypeExtensionTest0784),
+                typeof(VolumeArchetypeExtensionTest0785),
+                typeof(VolumeArchetypeExtensionTest0786),
+                typeof(VolumeArchetypeExtensionTest0787),
+                typeof(VolumeArchetypeExtensionTest0788),
+                typeof(VolumeArchetypeExtensionTest0789),
+                typeof(VolumeArchetypeExtensionTest0790),
+                typeof(VolumeArchetypeExtensionTest0791),
+                typeof(VolumeArchetypeExtensionTest0792),
+                typeof(VolumeArchetypeExtensionTest0793),
+                typeof(VolumeArchetypeExtensionTest0794),
+                typeof(VolumeArchetypeExtensionTest0795),
+                typeof(VolumeArchetypeExtensionTest0796),
+                typeof(VolumeArchetypeExtensionTest0797),
+                typeof(VolumeArchetypeExtensionTest0798),
+                typeof(VolumeArchetypeExtensionTest0799),
+                typeof(VolumeArchetypeExtensionTest0800),
+                typeof(VolumeArchetypeExtensionTest0801),
+                typeof(VolumeArchetypeExtensionTest0802),
+                typeof(VolumeArchetypeExtensionTest0803),
+                typeof(VolumeArchetypeExtensionTest0804),
+                typeof(VolumeArchetypeExtensionTest0805),
+                typeof(VolumeArchetypeExtensionTest0806),
+                typeof(VolumeArchetypeExtensionTest0807),
+                typeof(VolumeArchetypeExtensionTest0808),
+                typeof(VolumeArchetypeExtensionTest0809),
+                typeof(VolumeArchetypeExtensionTest0810),
+                typeof(VolumeArchetypeExtensionTest0811),
+                typeof(VolumeArchetypeExtensionTest0812),
+                typeof(VolumeArchetypeExtensionTest0813),
+                typeof(VolumeArchetypeExtensionTest0814),
+                typeof(VolumeArchetypeExtensionTest0815),
+                typeof(VolumeArchetypeExtensionTest0816),
+                typeof(VolumeArchetypeExtensionTest0817),
+                typeof(VolumeArchetypeExtensionTest0818),
+                typeof(VolumeArchetypeExtensionTest0819),
+                typeof(VolumeArchetypeExtensionTest0820),
+                typeof(VolumeArchetypeExtensionTest0821),
+                typeof(VolumeArchetypeExtensionTest0822),
+                typeof(VolumeArchetypeExtensionTest0823),
+                typeof(VolumeArchetypeExtensionTest0824),
+                typeof(VolumeArchetypeExtensionTest0825),
+                typeof(VolumeArchetypeExtensionTest0826),
+                typeof(VolumeArchetypeExtensionTest0827),
+                typeof(VolumeArchetypeExtensionTest0828),
+                typeof(VolumeArchetypeExtensionTest0829),
+                typeof(VolumeArchetypeExtensionTest0830),
+                typeof(VolumeArchetypeExtensionTest0831),
+                typeof(VolumeArchetypeExtensionTest0832),
+                typeof(VolumeArchetypeExtensionTest0833),
+                typeof(VolumeArchetypeExtensionTest0834),
+                typeof(VolumeArchetypeExtensionTest0835),
+                typeof(VolumeArchetypeExtensionTest0836),
+                typeof(VolumeArchetypeExtensionTest0837),
+                typeof(VolumeArchetypeExtensionTest0838),
+                typeof(VolumeArchetypeExtensionTest0839),
+                typeof(VolumeArchetypeExtensionTest0840),
+                typeof(VolumeArchetypeExtensionTest0841),
+                typeof(VolumeArchetypeExtensionTest0842),
+                typeof(VolumeArchetypeExtensionTest0843),
+                typeof(VolumeArchetypeExtensionTest0844),
+                typeof(VolumeArchetypeExtensionTest0845),
+                typeof(VolumeArchetypeExtensionTest0846),
+                typeof(VolumeArchetypeExtensionTest0847),
+                typeof(VolumeArchetypeExtensionTest0848),
+                typeof(VolumeArchetypeExtensionTest0849),
+                typeof(VolumeArchetypeExtensionTest0850),
+                typeof(VolumeArchetypeExtensionTest0851),
+                typeof(VolumeArchetypeExtensionTest0852),
+                typeof(VolumeArchetypeExtensionTest0853),
+                typeof(VolumeArchetypeExtensionTest0854),
+                typeof(VolumeArchetypeExtensionTest0855),
+                typeof(VolumeArchetypeExtensionTest0856),
+                typeof(VolumeArchetypeExtensionTest0857),
+                typeof(VolumeArchetypeExtensionTest0858),
+                typeof(VolumeArchetypeExtensionTest0859),
+                typeof(VolumeArchetypeExtensionTest0860),
+                typeof(VolumeArchetypeExtensionTest0861),
+                typeof(VolumeArchetypeExtensionTest0862),
+                typeof(VolumeArchetypeExtensionTest0863),
+                typeof(VolumeArchetypeExtensionTest0864),
+                typeof(VolumeArchetypeExtensionTest0865),
+                typeof(VolumeArchetypeExtensionTest0866),
+                typeof(VolumeArchetypeExtensionTest0867),
+                typeof(VolumeArchetypeExtensionTest0868),
+                typeof(VolumeArchetypeExtensionTest0869),
+                typeof(VolumeArchetypeExtensionTest0870),
+                typeof(VolumeArchetypeExtensionTest0871),
+                typeof(VolumeArchetypeExtensionTest0872),
+                typeof(VolumeArchetypeExtensionTest0873),
+                typeof(VolumeArchetypeExtensionTest0874),
+                typeof(VolumeArchetypeExtensionTest0875),
+                typeof(VolumeArchetypeExtensionTest0876),
+                typeof(VolumeArchetypeExtensionTest0877),
+                typeof(VolumeArchetypeExtensionTest0878),
+                typeof(VolumeArchetypeExtensionTest0879),
+                typeof(VolumeArchetypeExtensionTest0880),
+                typeof(VolumeArchetypeExtensionTest0881),
+                typeof(VolumeArchetypeExtensionTest0882),
+                typeof(VolumeArchetypeExtensionTest0883),
+                typeof(VolumeArchetypeExtensionTest0884),
+                typeof(VolumeArchetypeExtensionTest0885),
+                typeof(VolumeArchetypeExtensionTest0886),
+                typeof(VolumeArchetypeExtensionTest0887),
+                typeof(VolumeArchetypeExtensionTest0888),
+                typeof(VolumeArchetypeExtensionTest0889),
+                typeof(VolumeArchetypeExtensionTest0890),
+                typeof(VolumeArchetypeExtensionTest0891),
+                typeof(VolumeArchetypeExtensionTest0892),
+                typeof(VolumeArchetypeExtensionTest0893),
+                typeof(VolumeArchetypeExtensionTest0894),
+                typeof(VolumeArchetypeExtensionTest0895),
+                typeof(VolumeArchetypeExtensionTest0896),
+                typeof(VolumeArchetypeExtensionTest0897),
+                typeof(VolumeArchetypeExtensionTest0898),
+                typeof(VolumeArchetypeExtensionTest0899),
+                typeof(VolumeArchetypeExtensionTest0900),
+                typeof(VolumeArchetypeExtensionTest0901),
+                typeof(VolumeArchetypeExtensionTest0902),
+                typeof(VolumeArchetypeExtensionTest0903),
+                typeof(VolumeArchetypeExtensionTest0904),
+                typeof(VolumeArchetypeExtensionTest0905),
+                typeof(VolumeArchetypeExtensionTest0906),
+                typeof(VolumeArchetypeExtensionTest0907),
+                typeof(VolumeArchetypeExtensionTest0908),
+                typeof(VolumeArchetypeExtensionTest0909),
+                typeof(VolumeArchetypeExtensionTest0910),
+                typeof(VolumeArchetypeExtensionTest0911),
+                typeof(VolumeArchetypeExtensionTest0912),
+                typeof(VolumeArchetypeExtensionTest0913),
+                typeof(VolumeArchetypeExtensionTest0914),
+                typeof(VolumeArchetypeExtensionTest0915),
+                typeof(VolumeArchetypeExtensionTest0916),
+                typeof(VolumeArchetypeExtensionTest0917),
+                typeof(VolumeArchetypeExtensionTest0918),
+                typeof(VolumeArchetypeExtensionTest0919),
+                typeof(VolumeArchetypeExtensionTest0920),
+                typeof(VolumeArchetypeExtensionTest0921),
+                typeof(VolumeArchetypeExtensionTest0922),
+                typeof(VolumeArchetypeExtensionTest0923),
+                typeof(VolumeArchetypeExtensionTest0924),
+                typeof(VolumeArchetypeExtensionTest0925),
+                typeof(VolumeArchetypeExtensionTest0926),
+                typeof(VolumeArchetypeExtensionTest0927),
+                typeof(VolumeArchetypeExtensionTest0928),
+                typeof(VolumeArchetypeExtensionTest0929),
+                typeof(VolumeArchetypeExtensionTest0930),
+                typeof(VolumeArchetypeExtensionTest0931),
+                typeof(VolumeArchetypeExtensionTest0932),
+                typeof(VolumeArchetypeExtensionTest0933),
+                typeof(VolumeArchetypeExtensionTest0934),
+                typeof(VolumeArchetypeExtensionTest0935),
+                typeof(VolumeArchetypeExtensionTest0936),
+                typeof(VolumeArchetypeExtensionTest0937),
+                typeof(VolumeArchetypeExtensionTest0938),
+                typeof(VolumeArchetypeExtensionTest0939),
+                typeof(VolumeArchetypeExtensionTest0940),
+                typeof(VolumeArchetypeExtensionTest0941),
+                typeof(VolumeArchetypeExtensionTest0942),
+                typeof(VolumeArchetypeExtensionTest0943),
+                typeof(VolumeArchetypeExtensionTest0944),
+                typeof(VolumeArchetypeExtensionTest0945),
+                typeof(VolumeArchetypeExtensionTest0946),
+                typeof(VolumeArchetypeExtensionTest0947),
+                typeof(VolumeArchetypeExtensionTest0948),
+                typeof(VolumeArchetypeExtensionTest0949),
+                typeof(VolumeArchetypeExtensionTest0950),
+                typeof(VolumeArchetypeExtensionTest0951),
+                typeof(VolumeArchetypeExtensionTest0952),
+                typeof(VolumeArchetypeExtensionTest0953),
+                typeof(VolumeArchetypeExtensionTest0954),
+                typeof(VolumeArchetypeExtensionTest0955),
+                typeof(VolumeArchetypeExtensionTest0956),
+                typeof(VolumeArchetypeExtensionTest0957),
+                typeof(VolumeArchetypeExtensionTest0958),
+                typeof(VolumeArchetypeExtensionTest0959),
+                typeof(VolumeArchetypeExtensionTest0960),
+                typeof(VolumeArchetypeExtensionTest0961),
+                typeof(VolumeArchetypeExtensionTest0962),
+                typeof(VolumeArchetypeExtensionTest0963),
+                typeof(VolumeArchetypeExtensionTest0964),
+                typeof(VolumeArchetypeExtensionTest0965),
+                typeof(VolumeArchetypeExtensionTest0966),
+                typeof(VolumeArchetypeExtensionTest0967),
+                typeof(VolumeArchetypeExtensionTest0968),
+                typeof(VolumeArchetypeExtensionTest0969),
+                typeof(VolumeArchetypeExtensionTest0970),
+                typeof(VolumeArchetypeExtensionTest0971),
+                typeof(VolumeArchetypeExtensionTest0972),
+                typeof(VolumeArchetypeExtensionTest0973),
+                typeof(VolumeArchetypeExtensionTest0974),
+                typeof(VolumeArchetypeExtensionTest0975),
+                typeof(VolumeArchetypeExtensionTest0976),
+                typeof(VolumeArchetypeExtensionTest0977),
+                typeof(VolumeArchetypeExtensionTest0978),
+                typeof(VolumeArchetypeExtensionTest0979),
+                typeof(VolumeArchetypeExtensionTest0980),
+                typeof(VolumeArchetypeExtensionTest0981),
+                typeof(VolumeArchetypeExtensionTest0982),
+                typeof(VolumeArchetypeExtensionTest0983),
+                typeof(VolumeArchetypeExtensionTest0984),
+                typeof(VolumeArchetypeExtensionTest0985),
+                typeof(VolumeArchetypeExtensionTest0986),
+                typeof(VolumeArchetypeExtensionTest0987),
+                typeof(VolumeArchetypeExtensionTest0988),
+                typeof(VolumeArchetypeExtensionTest0989),
+                typeof(VolumeArchetypeExtensionTest0990),
+                typeof(VolumeArchetypeExtensionTest0991),
+                typeof(VolumeArchetypeExtensionTest0992),
+                typeof(VolumeArchetypeExtensionTest0993),
+                typeof(VolumeArchetypeExtensionTest0994),
+                typeof(VolumeArchetypeExtensionTest0995),
+                typeof(VolumeArchetypeExtensionTest0996),
+                typeof(VolumeArchetypeExtensionTest0997),
+                typeof(VolumeArchetypeExtensionTest0998),
+                typeof(VolumeArchetypeExtensionTest0999),
+            };
+            public class VolumeArchetypeExtensionTest0000 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0000>
+                {
+                    public VolumeArchetypeExtensionTest0000 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0000();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0001 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0001>
+                {
+                    public VolumeArchetypeExtensionTest0001 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0001();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0002 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0002>
+                {
+                    public VolumeArchetypeExtensionTest0002 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0002();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0003 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0003>
+                {
+                    public VolumeArchetypeExtensionTest0003 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0003();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0004 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0004>
+                {
+                    public VolumeArchetypeExtensionTest0004 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0004();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0005 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0005>
+                {
+                    public VolumeArchetypeExtensionTest0005 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0005();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0006 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0006>
+                {
+                    public VolumeArchetypeExtensionTest0006 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0006();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0007 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0007>
+                {
+                    public VolumeArchetypeExtensionTest0007 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0007();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0008 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0008>
+                {
+                    public VolumeArchetypeExtensionTest0008 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0008();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0009 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0009>
+                {
+                    public VolumeArchetypeExtensionTest0009 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0009();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0010 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0010>
+                {
+                    public VolumeArchetypeExtensionTest0010 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0010();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0011 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0011>
+                {
+                    public VolumeArchetypeExtensionTest0011 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0011();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0012 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0012>
+                {
+                    public VolumeArchetypeExtensionTest0012 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0012();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0013 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0013>
+                {
+                    public VolumeArchetypeExtensionTest0013 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0013();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0014 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0014>
+                {
+                    public VolumeArchetypeExtensionTest0014 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0014();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0015 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0015>
+                {
+                    public VolumeArchetypeExtensionTest0015 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0015();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0016 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0016>
+                {
+                    public VolumeArchetypeExtensionTest0016 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0016();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0017 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0017>
+                {
+                    public VolumeArchetypeExtensionTest0017 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0017();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0018 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0018>
+                {
+                    public VolumeArchetypeExtensionTest0018 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0018();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0019 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0019>
+                {
+                    public VolumeArchetypeExtensionTest0019 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0019();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0020 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0020>
+                {
+                    public VolumeArchetypeExtensionTest0020 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0020();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0021 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0021>
+                {
+                    public VolumeArchetypeExtensionTest0021 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0021();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0022 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0022>
+                {
+                    public VolumeArchetypeExtensionTest0022 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0022();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0023 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0023>
+                {
+                    public VolumeArchetypeExtensionTest0023 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0023();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0024 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0024>
+                {
+                    public VolumeArchetypeExtensionTest0024 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0024();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0025 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0025>
+                {
+                    public VolumeArchetypeExtensionTest0025 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0025();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0026 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0026>
+                {
+                    public VolumeArchetypeExtensionTest0026 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0026();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0027 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0027>
+                {
+                    public VolumeArchetypeExtensionTest0027 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0027();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0028 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0028>
+                {
+                    public VolumeArchetypeExtensionTest0028 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0028();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0029 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0029>
+                {
+                    public VolumeArchetypeExtensionTest0029 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0029();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0030 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0030>
+                {
+                    public VolumeArchetypeExtensionTest0030 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0030();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0031 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0031>
+                {
+                    public VolumeArchetypeExtensionTest0031 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0031();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0032 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0032>
+                {
+                    public VolumeArchetypeExtensionTest0032 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0032();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0033 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0033>
+                {
+                    public VolumeArchetypeExtensionTest0033 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0033();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0034 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0034>
+                {
+                    public VolumeArchetypeExtensionTest0034 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0034();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0035 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0035>
+                {
+                    public VolumeArchetypeExtensionTest0035 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0035();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0036 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0036>
+                {
+                    public VolumeArchetypeExtensionTest0036 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0036();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0037 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0037>
+                {
+                    public VolumeArchetypeExtensionTest0037 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0037();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0038 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0038>
+                {
+                    public VolumeArchetypeExtensionTest0038 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0038();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0039 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0039>
+                {
+                    public VolumeArchetypeExtensionTest0039 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0039();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0040 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0040>
+                {
+                    public VolumeArchetypeExtensionTest0040 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0040();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0041 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0041>
+                {
+                    public VolumeArchetypeExtensionTest0041 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0041();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0042 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0042>
+                {
+                    public VolumeArchetypeExtensionTest0042 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0042();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0043 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0043>
+                {
+                    public VolumeArchetypeExtensionTest0043 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0043();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0044 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0044>
+                {
+                    public VolumeArchetypeExtensionTest0044 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0044();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0045 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0045>
+                {
+                    public VolumeArchetypeExtensionTest0045 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0045();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0046 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0046>
+                {
+                    public VolumeArchetypeExtensionTest0046 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0046();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0047 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0047>
+                {
+                    public VolumeArchetypeExtensionTest0047 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0047();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0048 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0048>
+                {
+                    public VolumeArchetypeExtensionTest0048 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0048();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0049 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0049>
+                {
+                    public VolumeArchetypeExtensionTest0049 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0049();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0050 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0050>
+                {
+                    public VolumeArchetypeExtensionTest0050 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0050();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0051 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0051>
+                {
+                    public VolumeArchetypeExtensionTest0051 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0051();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0052 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0052>
+                {
+                    public VolumeArchetypeExtensionTest0052 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0052();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0053 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0053>
+                {
+                    public VolumeArchetypeExtensionTest0053 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0053();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0054 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0054>
+                {
+                    public VolumeArchetypeExtensionTest0054 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0054();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0055 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0055>
+                {
+                    public VolumeArchetypeExtensionTest0055 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0055();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0056 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0056>
+                {
+                    public VolumeArchetypeExtensionTest0056 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0056();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0057 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0057>
+                {
+                    public VolumeArchetypeExtensionTest0057 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0057();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0058 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0058>
+                {
+                    public VolumeArchetypeExtensionTest0058 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0058();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0059 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0059>
+                {
+                    public VolumeArchetypeExtensionTest0059 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0059();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0060 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0060>
+                {
+                    public VolumeArchetypeExtensionTest0060 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0060();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0061 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0061>
+                {
+                    public VolumeArchetypeExtensionTest0061 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0061();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0062 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0062>
+                {
+                    public VolumeArchetypeExtensionTest0062 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0062();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0063 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0063>
+                {
+                    public VolumeArchetypeExtensionTest0063 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0063();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0064 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0064>
+                {
+                    public VolumeArchetypeExtensionTest0064 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0064();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0065 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0065>
+                {
+                    public VolumeArchetypeExtensionTest0065 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0065();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0066 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0066>
+                {
+                    public VolumeArchetypeExtensionTest0066 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0066();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0067 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0067>
+                {
+                    public VolumeArchetypeExtensionTest0067 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0067();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0068 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0068>
+                {
+                    public VolumeArchetypeExtensionTest0068 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0068();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0069 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0069>
+                {
+                    public VolumeArchetypeExtensionTest0069 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0069();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0070 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0070>
+                {
+                    public VolumeArchetypeExtensionTest0070 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0070();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0071 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0071>
+                {
+                    public VolumeArchetypeExtensionTest0071 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0071();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0072 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0072>
+                {
+                    public VolumeArchetypeExtensionTest0072 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0072();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0073 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0073>
+                {
+                    public VolumeArchetypeExtensionTest0073 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0073();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0074 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0074>
+                {
+                    public VolumeArchetypeExtensionTest0074 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0074();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0075 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0075>
+                {
+                    public VolumeArchetypeExtensionTest0075 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0075();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0076 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0076>
+                {
+                    public VolumeArchetypeExtensionTest0076 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0076();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0077 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0077>
+                {
+                    public VolumeArchetypeExtensionTest0077 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0077();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0078 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0078>
+                {
+                    public VolumeArchetypeExtensionTest0078 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0078();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0079 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0079>
+                {
+                    public VolumeArchetypeExtensionTest0079 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0079();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0080 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0080>
+                {
+                    public VolumeArchetypeExtensionTest0080 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0080();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0081 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0081>
+                {
+                    public VolumeArchetypeExtensionTest0081 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0081();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0082 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0082>
+                {
+                    public VolumeArchetypeExtensionTest0082 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0082();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0083 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0083>
+                {
+                    public VolumeArchetypeExtensionTest0083 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0083();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0084 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0084>
+                {
+                    public VolumeArchetypeExtensionTest0084 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0084();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0085 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0085>
+                {
+                    public VolumeArchetypeExtensionTest0085 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0085();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0086 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0086>
+                {
+                    public VolumeArchetypeExtensionTest0086 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0086();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0087 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0087>
+                {
+                    public VolumeArchetypeExtensionTest0087 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0087();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0088 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0088>
+                {
+                    public VolumeArchetypeExtensionTest0088 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0088();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0089 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0089>
+                {
+                    public VolumeArchetypeExtensionTest0089 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0089();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0090 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0090>
+                {
+                    public VolumeArchetypeExtensionTest0090 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0090();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0091 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0091>
+                {
+                    public VolumeArchetypeExtensionTest0091 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0091();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0092 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0092>
+                {
+                    public VolumeArchetypeExtensionTest0092 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0092();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0093 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0093>
+                {
+                    public VolumeArchetypeExtensionTest0093 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0093();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0094 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0094>
+                {
+                    public VolumeArchetypeExtensionTest0094 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0094();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0095 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0095>
+                {
+                    public VolumeArchetypeExtensionTest0095 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0095();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0096 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0096>
+                {
+                    public VolumeArchetypeExtensionTest0096 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0096();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0097 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0097>
+                {
+                    public VolumeArchetypeExtensionTest0097 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0097();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0098 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0098>
+                {
+                    public VolumeArchetypeExtensionTest0098 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0098();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0099 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0099>
+                {
+                    public VolumeArchetypeExtensionTest0099 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0099();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0100 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0100>
+                {
+                    public VolumeArchetypeExtensionTest0100 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0100();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0101 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0101>
+                {
+                    public VolumeArchetypeExtensionTest0101 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0101();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0102 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0102>
+                {
+                    public VolumeArchetypeExtensionTest0102 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0102();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0103 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0103>
+                {
+                    public VolumeArchetypeExtensionTest0103 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0103();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0104 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0104>
+                {
+                    public VolumeArchetypeExtensionTest0104 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0104();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0105 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0105>
+                {
+                    public VolumeArchetypeExtensionTest0105 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0105();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0106 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0106>
+                {
+                    public VolumeArchetypeExtensionTest0106 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0106();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0107 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0107>
+                {
+                    public VolumeArchetypeExtensionTest0107 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0107();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0108 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0108>
+                {
+                    public VolumeArchetypeExtensionTest0108 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0108();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0109 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0109>
+                {
+                    public VolumeArchetypeExtensionTest0109 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0109();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0110 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0110>
+                {
+                    public VolumeArchetypeExtensionTest0110 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0110();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0111 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0111>
+                {
+                    public VolumeArchetypeExtensionTest0111 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0111();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0112 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0112>
+                {
+                    public VolumeArchetypeExtensionTest0112 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0112();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0113 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0113>
+                {
+                    public VolumeArchetypeExtensionTest0113 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0113();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0114 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0114>
+                {
+                    public VolumeArchetypeExtensionTest0114 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0114();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0115 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0115>
+                {
+                    public VolumeArchetypeExtensionTest0115 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0115();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0116 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0116>
+                {
+                    public VolumeArchetypeExtensionTest0116 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0116();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0117 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0117>
+                {
+                    public VolumeArchetypeExtensionTest0117 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0117();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0118 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0118>
+                {
+                    public VolumeArchetypeExtensionTest0118 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0118();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0119 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0119>
+                {
+                    public VolumeArchetypeExtensionTest0119 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0119();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0120 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0120>
+                {
+                    public VolumeArchetypeExtensionTest0120 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0120();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0121 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0121>
+                {
+                    public VolumeArchetypeExtensionTest0121 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0121();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0122 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0122>
+                {
+                    public VolumeArchetypeExtensionTest0122 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0122();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0123 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0123>
+                {
+                    public VolumeArchetypeExtensionTest0123 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0123();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0124 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0124>
+                {
+                    public VolumeArchetypeExtensionTest0124 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0124();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0125 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0125>
+                {
+                    public VolumeArchetypeExtensionTest0125 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0125();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0126 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0126>
+                {
+                    public VolumeArchetypeExtensionTest0126 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0126();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0127 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0127>
+                {
+                    public VolumeArchetypeExtensionTest0127 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0127();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0128 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0128>
+                {
+                    public VolumeArchetypeExtensionTest0128 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0128();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0129 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0129>
+                {
+                    public VolumeArchetypeExtensionTest0129 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0129();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0130 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0130>
+                {
+                    public VolumeArchetypeExtensionTest0130 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0130();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0131 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0131>
+                {
+                    public VolumeArchetypeExtensionTest0131 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0131();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0132 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0132>
+                {
+                    public VolumeArchetypeExtensionTest0132 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0132();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0133 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0133>
+                {
+                    public VolumeArchetypeExtensionTest0133 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0133();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0134 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0134>
+                {
+                    public VolumeArchetypeExtensionTest0134 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0134();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0135 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0135>
+                {
+                    public VolumeArchetypeExtensionTest0135 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0135();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0136 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0136>
+                {
+                    public VolumeArchetypeExtensionTest0136 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0136();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0137 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0137>
+                {
+                    public VolumeArchetypeExtensionTest0137 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0137();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0138 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0138>
+                {
+                    public VolumeArchetypeExtensionTest0138 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0138();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0139 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0139>
+                {
+                    public VolumeArchetypeExtensionTest0139 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0139();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0140 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0140>
+                {
+                    public VolumeArchetypeExtensionTest0140 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0140();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0141 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0141>
+                {
+                    public VolumeArchetypeExtensionTest0141 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0141();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0142 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0142>
+                {
+                    public VolumeArchetypeExtensionTest0142 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0142();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0143 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0143>
+                {
+                    public VolumeArchetypeExtensionTest0143 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0143();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0144 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0144>
+                {
+                    public VolumeArchetypeExtensionTest0144 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0144();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0145 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0145>
+                {
+                    public VolumeArchetypeExtensionTest0145 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0145();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0146 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0146>
+                {
+                    public VolumeArchetypeExtensionTest0146 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0146();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0147 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0147>
+                {
+                    public VolumeArchetypeExtensionTest0147 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0147();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0148 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0148>
+                {
+                    public VolumeArchetypeExtensionTest0148 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0148();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0149 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0149>
+                {
+                    public VolumeArchetypeExtensionTest0149 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0149();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0150 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0150>
+                {
+                    public VolumeArchetypeExtensionTest0150 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0150();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0151 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0151>
+                {
+                    public VolumeArchetypeExtensionTest0151 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0151();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0152 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0152>
+                {
+                    public VolumeArchetypeExtensionTest0152 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0152();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0153 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0153>
+                {
+                    public VolumeArchetypeExtensionTest0153 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0153();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0154 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0154>
+                {
+                    public VolumeArchetypeExtensionTest0154 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0154();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0155 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0155>
+                {
+                    public VolumeArchetypeExtensionTest0155 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0155();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0156 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0156>
+                {
+                    public VolumeArchetypeExtensionTest0156 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0156();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0157 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0157>
+                {
+                    public VolumeArchetypeExtensionTest0157 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0157();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0158 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0158>
+                {
+                    public VolumeArchetypeExtensionTest0158 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0158();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0159 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0159>
+                {
+                    public VolumeArchetypeExtensionTest0159 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0159();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0160 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0160>
+                {
+                    public VolumeArchetypeExtensionTest0160 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0160();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0161 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0161>
+                {
+                    public VolumeArchetypeExtensionTest0161 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0161();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0162 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0162>
+                {
+                    public VolumeArchetypeExtensionTest0162 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0162();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0163 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0163>
+                {
+                    public VolumeArchetypeExtensionTest0163 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0163();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0164 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0164>
+                {
+                    public VolumeArchetypeExtensionTest0164 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0164();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0165 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0165>
+                {
+                    public VolumeArchetypeExtensionTest0165 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0165();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0166 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0166>
+                {
+                    public VolumeArchetypeExtensionTest0166 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0166();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0167 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0167>
+                {
+                    public VolumeArchetypeExtensionTest0167 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0167();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0168 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0168>
+                {
+                    public VolumeArchetypeExtensionTest0168 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0168();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0169 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0169>
+                {
+                    public VolumeArchetypeExtensionTest0169 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0169();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0170 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0170>
+                {
+                    public VolumeArchetypeExtensionTest0170 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0170();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0171 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0171>
+                {
+                    public VolumeArchetypeExtensionTest0171 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0171();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0172 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0172>
+                {
+                    public VolumeArchetypeExtensionTest0172 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0172();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0173 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0173>
+                {
+                    public VolumeArchetypeExtensionTest0173 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0173();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0174 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0174>
+                {
+                    public VolumeArchetypeExtensionTest0174 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0174();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0175 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0175>
+                {
+                    public VolumeArchetypeExtensionTest0175 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0175();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0176 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0176>
+                {
+                    public VolumeArchetypeExtensionTest0176 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0176();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0177 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0177>
+                {
+                    public VolumeArchetypeExtensionTest0177 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0177();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0178 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0178>
+                {
+                    public VolumeArchetypeExtensionTest0178 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0178();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0179 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0179>
+                {
+                    public VolumeArchetypeExtensionTest0179 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0179();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0180 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0180>
+                {
+                    public VolumeArchetypeExtensionTest0180 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0180();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0181 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0181>
+                {
+                    public VolumeArchetypeExtensionTest0181 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0181();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0182 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0182>
+                {
+                    public VolumeArchetypeExtensionTest0182 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0182();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0183 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0183>
+                {
+                    public VolumeArchetypeExtensionTest0183 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0183();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0184 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0184>
+                {
+                    public VolumeArchetypeExtensionTest0184 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0184();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0185 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0185>
+                {
+                    public VolumeArchetypeExtensionTest0185 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0185();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0186 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0186>
+                {
+                    public VolumeArchetypeExtensionTest0186 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0186();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0187 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0187>
+                {
+                    public VolumeArchetypeExtensionTest0187 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0187();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0188 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0188>
+                {
+                    public VolumeArchetypeExtensionTest0188 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0188();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0189 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0189>
+                {
+                    public VolumeArchetypeExtensionTest0189 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0189();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0190 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0190>
+                {
+                    public VolumeArchetypeExtensionTest0190 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0190();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0191 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0191>
+                {
+                    public VolumeArchetypeExtensionTest0191 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0191();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0192 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0192>
+                {
+                    public VolumeArchetypeExtensionTest0192 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0192();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0193 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0193>
+                {
+                    public VolumeArchetypeExtensionTest0193 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0193();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0194 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0194>
+                {
+                    public VolumeArchetypeExtensionTest0194 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0194();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0195 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0195>
+                {
+                    public VolumeArchetypeExtensionTest0195 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0195();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0196 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0196>
+                {
+                    public VolumeArchetypeExtensionTest0196 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0196();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0197 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0197>
+                {
+                    public VolumeArchetypeExtensionTest0197 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0197();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0198 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0198>
+                {
+                    public VolumeArchetypeExtensionTest0198 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0198();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0199 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0199>
+                {
+                    public VolumeArchetypeExtensionTest0199 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0199();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0200 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0200>
+                {
+                    public VolumeArchetypeExtensionTest0200 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0200();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0201 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0201>
+                {
+                    public VolumeArchetypeExtensionTest0201 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0201();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0202 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0202>
+                {
+                    public VolumeArchetypeExtensionTest0202 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0202();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0203 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0203>
+                {
+                    public VolumeArchetypeExtensionTest0203 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0203();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0204 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0204>
+                {
+                    public VolumeArchetypeExtensionTest0204 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0204();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0205 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0205>
+                {
+                    public VolumeArchetypeExtensionTest0205 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0205();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0206 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0206>
+                {
+                    public VolumeArchetypeExtensionTest0206 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0206();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0207 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0207>
+                {
+                    public VolumeArchetypeExtensionTest0207 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0207();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0208 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0208>
+                {
+                    public VolumeArchetypeExtensionTest0208 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0208();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0209 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0209>
+                {
+                    public VolumeArchetypeExtensionTest0209 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0209();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0210 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0210>
+                {
+                    public VolumeArchetypeExtensionTest0210 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0210();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0211 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0211>
+                {
+                    public VolumeArchetypeExtensionTest0211 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0211();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0212 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0212>
+                {
+                    public VolumeArchetypeExtensionTest0212 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0212();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0213 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0213>
+                {
+                    public VolumeArchetypeExtensionTest0213 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0213();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0214 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0214>
+                {
+                    public VolumeArchetypeExtensionTest0214 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0214();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0215 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0215>
+                {
+                    public VolumeArchetypeExtensionTest0215 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0215();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0216 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0216>
+                {
+                    public VolumeArchetypeExtensionTest0216 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0216();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0217 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0217>
+                {
+                    public VolumeArchetypeExtensionTest0217 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0217();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0218 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0218>
+                {
+                    public VolumeArchetypeExtensionTest0218 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0218();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0219 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0219>
+                {
+                    public VolumeArchetypeExtensionTest0219 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0219();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0220 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0220>
+                {
+                    public VolumeArchetypeExtensionTest0220 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0220();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0221 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0221>
+                {
+                    public VolumeArchetypeExtensionTest0221 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0221();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0222 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0222>
+                {
+                    public VolumeArchetypeExtensionTest0222 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0222();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0223 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0223>
+                {
+                    public VolumeArchetypeExtensionTest0223 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0223();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0224 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0224>
+                {
+                    public VolumeArchetypeExtensionTest0224 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0224();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0225 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0225>
+                {
+                    public VolumeArchetypeExtensionTest0225 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0225();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0226 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0226>
+                {
+                    public VolumeArchetypeExtensionTest0226 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0226();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0227 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0227>
+                {
+                    public VolumeArchetypeExtensionTest0227 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0227();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0228 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0228>
+                {
+                    public VolumeArchetypeExtensionTest0228 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0228();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0229 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0229>
+                {
+                    public VolumeArchetypeExtensionTest0229 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0229();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0230 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0230>
+                {
+                    public VolumeArchetypeExtensionTest0230 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0230();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0231 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0231>
+                {
+                    public VolumeArchetypeExtensionTest0231 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0231();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0232 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0232>
+                {
+                    public VolumeArchetypeExtensionTest0232 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0232();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0233 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0233>
+                {
+                    public VolumeArchetypeExtensionTest0233 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0233();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0234 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0234>
+                {
+                    public VolumeArchetypeExtensionTest0234 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0234();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0235 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0235>
+                {
+                    public VolumeArchetypeExtensionTest0235 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0235();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0236 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0236>
+                {
+                    public VolumeArchetypeExtensionTest0236 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0236();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0237 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0237>
+                {
+                    public VolumeArchetypeExtensionTest0237 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0237();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0238 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0238>
+                {
+                    public VolumeArchetypeExtensionTest0238 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0238();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0239 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0239>
+                {
+                    public VolumeArchetypeExtensionTest0239 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0239();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0240 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0240>
+                {
+                    public VolumeArchetypeExtensionTest0240 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0240();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0241 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0241>
+                {
+                    public VolumeArchetypeExtensionTest0241 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0241();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0242 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0242>
+                {
+                    public VolumeArchetypeExtensionTest0242 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0242();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0243 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0243>
+                {
+                    public VolumeArchetypeExtensionTest0243 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0243();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0244 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0244>
+                {
+                    public VolumeArchetypeExtensionTest0244 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0244();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0245 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0245>
+                {
+                    public VolumeArchetypeExtensionTest0245 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0245();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0246 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0246>
+                {
+                    public VolumeArchetypeExtensionTest0246 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0246();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0247 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0247>
+                {
+                    public VolumeArchetypeExtensionTest0247 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0247();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0248 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0248>
+                {
+                    public VolumeArchetypeExtensionTest0248 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0248();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0249 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0249>
+                {
+                    public VolumeArchetypeExtensionTest0249 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0249();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0250 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0250>
+                {
+                    public VolumeArchetypeExtensionTest0250 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0250();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0251 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0251>
+                {
+                    public VolumeArchetypeExtensionTest0251 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0251();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0252 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0252>
+                {
+                    public VolumeArchetypeExtensionTest0252 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0252();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0253 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0253>
+                {
+                    public VolumeArchetypeExtensionTest0253 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0253();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0254 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0254>
+                {
+                    public VolumeArchetypeExtensionTest0254 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0254();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0255 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0255>
+                {
+                    public VolumeArchetypeExtensionTest0255 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0255();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0256 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0256>
+                {
+                    public VolumeArchetypeExtensionTest0256 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0256();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0257 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0257>
+                {
+                    public VolumeArchetypeExtensionTest0257 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0257();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0258 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0258>
+                {
+                    public VolumeArchetypeExtensionTest0258 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0258();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0259 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0259>
+                {
+                    public VolumeArchetypeExtensionTest0259 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0259();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0260 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0260>
+                {
+                    public VolumeArchetypeExtensionTest0260 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0260();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0261 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0261>
+                {
+                    public VolumeArchetypeExtensionTest0261 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0261();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0262 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0262>
+                {
+                    public VolumeArchetypeExtensionTest0262 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0262();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0263 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0263>
+                {
+                    public VolumeArchetypeExtensionTest0263 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0263();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0264 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0264>
+                {
+                    public VolumeArchetypeExtensionTest0264 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0264();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0265 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0265>
+                {
+                    public VolumeArchetypeExtensionTest0265 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0265();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0266 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0266>
+                {
+                    public VolumeArchetypeExtensionTest0266 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0266();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0267 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0267>
+                {
+                    public VolumeArchetypeExtensionTest0267 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0267();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0268 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0268>
+                {
+                    public VolumeArchetypeExtensionTest0268 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0268();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0269 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0269>
+                {
+                    public VolumeArchetypeExtensionTest0269 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0269();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0270 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0270>
+                {
+                    public VolumeArchetypeExtensionTest0270 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0270();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0271 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0271>
+                {
+                    public VolumeArchetypeExtensionTest0271 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0271();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0272 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0272>
+                {
+                    public VolumeArchetypeExtensionTest0272 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0272();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0273 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0273>
+                {
+                    public VolumeArchetypeExtensionTest0273 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0273();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0274 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0274>
+                {
+                    public VolumeArchetypeExtensionTest0274 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0274();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0275 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0275>
+                {
+                    public VolumeArchetypeExtensionTest0275 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0275();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0276 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0276>
+                {
+                    public VolumeArchetypeExtensionTest0276 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0276();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0277 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0277>
+                {
+                    public VolumeArchetypeExtensionTest0277 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0277();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0278 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0278>
+                {
+                    public VolumeArchetypeExtensionTest0278 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0278();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0279 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0279>
+                {
+                    public VolumeArchetypeExtensionTest0279 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0279();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0280 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0280>
+                {
+                    public VolumeArchetypeExtensionTest0280 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0280();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0281 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0281>
+                {
+                    public VolumeArchetypeExtensionTest0281 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0281();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0282 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0282>
+                {
+                    public VolumeArchetypeExtensionTest0282 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0282();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0283 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0283>
+                {
+                    public VolumeArchetypeExtensionTest0283 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0283();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0284 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0284>
+                {
+                    public VolumeArchetypeExtensionTest0284 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0284();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0285 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0285>
+                {
+                    public VolumeArchetypeExtensionTest0285 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0285();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0286 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0286>
+                {
+                    public VolumeArchetypeExtensionTest0286 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0286();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0287 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0287>
+                {
+                    public VolumeArchetypeExtensionTest0287 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0287();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0288 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0288>
+                {
+                    public VolumeArchetypeExtensionTest0288 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0288();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0289 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0289>
+                {
+                    public VolumeArchetypeExtensionTest0289 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0289();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0290 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0290>
+                {
+                    public VolumeArchetypeExtensionTest0290 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0290();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0291 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0291>
+                {
+                    public VolumeArchetypeExtensionTest0291 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0291();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0292 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0292>
+                {
+                    public VolumeArchetypeExtensionTest0292 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0292();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0293 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0293>
+                {
+                    public VolumeArchetypeExtensionTest0293 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0293();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0294 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0294>
+                {
+                    public VolumeArchetypeExtensionTest0294 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0294();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0295 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0295>
+                {
+                    public VolumeArchetypeExtensionTest0295 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0295();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0296 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0296>
+                {
+                    public VolumeArchetypeExtensionTest0296 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0296();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0297 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0297>
+                {
+                    public VolumeArchetypeExtensionTest0297 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0297();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0298 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0298>
+                {
+                    public VolumeArchetypeExtensionTest0298 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0298();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0299 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0299>
+                {
+                    public VolumeArchetypeExtensionTest0299 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0299();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0300 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0300>
+                {
+                    public VolumeArchetypeExtensionTest0300 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0300();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0301 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0301>
+                {
+                    public VolumeArchetypeExtensionTest0301 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0301();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0302 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0302>
+                {
+                    public VolumeArchetypeExtensionTest0302 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0302();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0303 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0303>
+                {
+                    public VolumeArchetypeExtensionTest0303 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0303();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0304 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0304>
+                {
+                    public VolumeArchetypeExtensionTest0304 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0304();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0305 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0305>
+                {
+                    public VolumeArchetypeExtensionTest0305 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0305();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0306 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0306>
+                {
+                    public VolumeArchetypeExtensionTest0306 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0306();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0307 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0307>
+                {
+                    public VolumeArchetypeExtensionTest0307 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0307();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0308 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0308>
+                {
+                    public VolumeArchetypeExtensionTest0308 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0308();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0309 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0309>
+                {
+                    public VolumeArchetypeExtensionTest0309 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0309();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0310 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0310>
+                {
+                    public VolumeArchetypeExtensionTest0310 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0310();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0311 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0311>
+                {
+                    public VolumeArchetypeExtensionTest0311 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0311();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0312 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0312>
+                {
+                    public VolumeArchetypeExtensionTest0312 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0312();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0313 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0313>
+                {
+                    public VolumeArchetypeExtensionTest0313 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0313();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0314 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0314>
+                {
+                    public VolumeArchetypeExtensionTest0314 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0314();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0315 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0315>
+                {
+                    public VolumeArchetypeExtensionTest0315 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0315();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0316 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0316>
+                {
+                    public VolumeArchetypeExtensionTest0316 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0316();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0317 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0317>
+                {
+                    public VolumeArchetypeExtensionTest0317 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0317();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0318 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0318>
+                {
+                    public VolumeArchetypeExtensionTest0318 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0318();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0319 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0319>
+                {
+                    public VolumeArchetypeExtensionTest0319 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0319();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0320 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0320>
+                {
+                    public VolumeArchetypeExtensionTest0320 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0320();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0321 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0321>
+                {
+                    public VolumeArchetypeExtensionTest0321 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0321();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0322 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0322>
+                {
+                    public VolumeArchetypeExtensionTest0322 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0322();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0323 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0323>
+                {
+                    public VolumeArchetypeExtensionTest0323 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0323();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0324 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0324>
+                {
+                    public VolumeArchetypeExtensionTest0324 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0324();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0325 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0325>
+                {
+                    public VolumeArchetypeExtensionTest0325 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0325();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0326 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0326>
+                {
+                    public VolumeArchetypeExtensionTest0326 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0326();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0327 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0327>
+                {
+                    public VolumeArchetypeExtensionTest0327 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0327();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0328 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0328>
+                {
+                    public VolumeArchetypeExtensionTest0328 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0328();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0329 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0329>
+                {
+                    public VolumeArchetypeExtensionTest0329 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0329();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0330 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0330>
+                {
+                    public VolumeArchetypeExtensionTest0330 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0330();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0331 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0331>
+                {
+                    public VolumeArchetypeExtensionTest0331 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0331();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0332 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0332>
+                {
+                    public VolumeArchetypeExtensionTest0332 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0332();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0333 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0333>
+                {
+                    public VolumeArchetypeExtensionTest0333 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0333();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0334 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0334>
+                {
+                    public VolumeArchetypeExtensionTest0334 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0334();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0335 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0335>
+                {
+                    public VolumeArchetypeExtensionTest0335 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0335();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0336 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0336>
+                {
+                    public VolumeArchetypeExtensionTest0336 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0336();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0337 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0337>
+                {
+                    public VolumeArchetypeExtensionTest0337 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0337();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0338 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0338>
+                {
+                    public VolumeArchetypeExtensionTest0338 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0338();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0339 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0339>
+                {
+                    public VolumeArchetypeExtensionTest0339 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0339();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0340 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0340>
+                {
+                    public VolumeArchetypeExtensionTest0340 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0340();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0341 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0341>
+                {
+                    public VolumeArchetypeExtensionTest0341 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0341();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0342 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0342>
+                {
+                    public VolumeArchetypeExtensionTest0342 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0342();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0343 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0343>
+                {
+                    public VolumeArchetypeExtensionTest0343 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0343();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0344 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0344>
+                {
+                    public VolumeArchetypeExtensionTest0344 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0344();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0345 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0345>
+                {
+                    public VolumeArchetypeExtensionTest0345 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0345();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0346 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0346>
+                {
+                    public VolumeArchetypeExtensionTest0346 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0346();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0347 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0347>
+                {
+                    public VolumeArchetypeExtensionTest0347 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0347();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0348 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0348>
+                {
+                    public VolumeArchetypeExtensionTest0348 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0348();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0349 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0349>
+                {
+                    public VolumeArchetypeExtensionTest0349 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0349();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0350 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0350>
+                {
+                    public VolumeArchetypeExtensionTest0350 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0350();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0351 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0351>
+                {
+                    public VolumeArchetypeExtensionTest0351 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0351();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0352 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0352>
+                {
+                    public VolumeArchetypeExtensionTest0352 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0352();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0353 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0353>
+                {
+                    public VolumeArchetypeExtensionTest0353 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0353();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0354 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0354>
+                {
+                    public VolumeArchetypeExtensionTest0354 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0354();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0355 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0355>
+                {
+                    public VolumeArchetypeExtensionTest0355 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0355();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0356 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0356>
+                {
+                    public VolumeArchetypeExtensionTest0356 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0356();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0357 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0357>
+                {
+                    public VolumeArchetypeExtensionTest0357 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0357();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0358 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0358>
+                {
+                    public VolumeArchetypeExtensionTest0358 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0358();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0359 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0359>
+                {
+                    public VolumeArchetypeExtensionTest0359 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0359();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0360 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0360>
+                {
+                    public VolumeArchetypeExtensionTest0360 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0360();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0361 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0361>
+                {
+                    public VolumeArchetypeExtensionTest0361 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0361();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0362 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0362>
+                {
+                    public VolumeArchetypeExtensionTest0362 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0362();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0363 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0363>
+                {
+                    public VolumeArchetypeExtensionTest0363 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0363();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0364 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0364>
+                {
+                    public VolumeArchetypeExtensionTest0364 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0364();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0365 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0365>
+                {
+                    public VolumeArchetypeExtensionTest0365 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0365();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0366 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0366>
+                {
+                    public VolumeArchetypeExtensionTest0366 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0366();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0367 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0367>
+                {
+                    public VolumeArchetypeExtensionTest0367 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0367();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0368 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0368>
+                {
+                    public VolumeArchetypeExtensionTest0368 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0368();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0369 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0369>
+                {
+                    public VolumeArchetypeExtensionTest0369 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0369();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0370 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0370>
+                {
+                    public VolumeArchetypeExtensionTest0370 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0370();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0371 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0371>
+                {
+                    public VolumeArchetypeExtensionTest0371 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0371();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0372 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0372>
+                {
+                    public VolumeArchetypeExtensionTest0372 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0372();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0373 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0373>
+                {
+                    public VolumeArchetypeExtensionTest0373 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0373();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0374 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0374>
+                {
+                    public VolumeArchetypeExtensionTest0374 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0374();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0375 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0375>
+                {
+                    public VolumeArchetypeExtensionTest0375 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0375();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0376 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0376>
+                {
+                    public VolumeArchetypeExtensionTest0376 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0376();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0377 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0377>
+                {
+                    public VolumeArchetypeExtensionTest0377 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0377();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0378 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0378>
+                {
+                    public VolumeArchetypeExtensionTest0378 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0378();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0379 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0379>
+                {
+                    public VolumeArchetypeExtensionTest0379 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0379();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0380 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0380>
+                {
+                    public VolumeArchetypeExtensionTest0380 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0380();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0381 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0381>
+                {
+                    public VolumeArchetypeExtensionTest0381 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0381();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0382 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0382>
+                {
+                    public VolumeArchetypeExtensionTest0382 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0382();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0383 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0383>
+                {
+                    public VolumeArchetypeExtensionTest0383 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0383();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0384 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0384>
+                {
+                    public VolumeArchetypeExtensionTest0384 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0384();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0385 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0385>
+                {
+                    public VolumeArchetypeExtensionTest0385 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0385();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0386 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0386>
+                {
+                    public VolumeArchetypeExtensionTest0386 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0386();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0387 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0387>
+                {
+                    public VolumeArchetypeExtensionTest0387 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0387();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0388 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0388>
+                {
+                    public VolumeArchetypeExtensionTest0388 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0388();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0389 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0389>
+                {
+                    public VolumeArchetypeExtensionTest0389 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0389();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0390 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0390>
+                {
+                    public VolumeArchetypeExtensionTest0390 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0390();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0391 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0391>
+                {
+                    public VolumeArchetypeExtensionTest0391 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0391();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0392 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0392>
+                {
+                    public VolumeArchetypeExtensionTest0392 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0392();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0393 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0393>
+                {
+                    public VolumeArchetypeExtensionTest0393 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0393();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0394 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0394>
+                {
+                    public VolumeArchetypeExtensionTest0394 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0394();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0395 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0395>
+                {
+                    public VolumeArchetypeExtensionTest0395 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0395();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0396 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0396>
+                {
+                    public VolumeArchetypeExtensionTest0396 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0396();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0397 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0397>
+                {
+                    public VolumeArchetypeExtensionTest0397 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0397();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0398 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0398>
+                {
+                    public VolumeArchetypeExtensionTest0398 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0398();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0399 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0399>
+                {
+                    public VolumeArchetypeExtensionTest0399 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0399();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0400 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0400>
+                {
+                    public VolumeArchetypeExtensionTest0400 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0400();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0401 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0401>
+                {
+                    public VolumeArchetypeExtensionTest0401 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0401();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0402 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0402>
+                {
+                    public VolumeArchetypeExtensionTest0402 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0402();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0403 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0403>
+                {
+                    public VolumeArchetypeExtensionTest0403 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0403();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0404 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0404>
+                {
+                    public VolumeArchetypeExtensionTest0404 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0404();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0405 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0405>
+                {
+                    public VolumeArchetypeExtensionTest0405 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0405();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0406 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0406>
+                {
+                    public VolumeArchetypeExtensionTest0406 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0406();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0407 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0407>
+                {
+                    public VolumeArchetypeExtensionTest0407 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0407();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0408 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0408>
+                {
+                    public VolumeArchetypeExtensionTest0408 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0408();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0409 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0409>
+                {
+                    public VolumeArchetypeExtensionTest0409 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0409();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0410 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0410>
+                {
+                    public VolumeArchetypeExtensionTest0410 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0410();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0411 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0411>
+                {
+                    public VolumeArchetypeExtensionTest0411 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0411();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0412 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0412>
+                {
+                    public VolumeArchetypeExtensionTest0412 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0412();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0413 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0413>
+                {
+                    public VolumeArchetypeExtensionTest0413 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0413();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0414 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0414>
+                {
+                    public VolumeArchetypeExtensionTest0414 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0414();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0415 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0415>
+                {
+                    public VolumeArchetypeExtensionTest0415 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0415();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0416 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0416>
+                {
+                    public VolumeArchetypeExtensionTest0416 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0416();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0417 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0417>
+                {
+                    public VolumeArchetypeExtensionTest0417 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0417();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0418 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0418>
+                {
+                    public VolumeArchetypeExtensionTest0418 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0418();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0419 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0419>
+                {
+                    public VolumeArchetypeExtensionTest0419 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0419();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0420 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0420>
+                {
+                    public VolumeArchetypeExtensionTest0420 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0420();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0421 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0421>
+                {
+                    public VolumeArchetypeExtensionTest0421 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0421();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0422 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0422>
+                {
+                    public VolumeArchetypeExtensionTest0422 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0422();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0423 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0423>
+                {
+                    public VolumeArchetypeExtensionTest0423 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0423();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0424 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0424>
+                {
+                    public VolumeArchetypeExtensionTest0424 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0424();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0425 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0425>
+                {
+                    public VolumeArchetypeExtensionTest0425 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0425();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0426 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0426>
+                {
+                    public VolumeArchetypeExtensionTest0426 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0426();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0427 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0427>
+                {
+                    public VolumeArchetypeExtensionTest0427 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0427();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0428 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0428>
+                {
+                    public VolumeArchetypeExtensionTest0428 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0428();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0429 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0429>
+                {
+                    public VolumeArchetypeExtensionTest0429 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0429();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0430 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0430>
+                {
+                    public VolumeArchetypeExtensionTest0430 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0430();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0431 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0431>
+                {
+                    public VolumeArchetypeExtensionTest0431 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0431();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0432 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0432>
+                {
+                    public VolumeArchetypeExtensionTest0432 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0432();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0433 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0433>
+                {
+                    public VolumeArchetypeExtensionTest0433 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0433();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0434 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0434>
+                {
+                    public VolumeArchetypeExtensionTest0434 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0434();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0435 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0435>
+                {
+                    public VolumeArchetypeExtensionTest0435 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0435();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0436 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0436>
+                {
+                    public VolumeArchetypeExtensionTest0436 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0436();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0437 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0437>
+                {
+                    public VolumeArchetypeExtensionTest0437 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0437();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0438 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0438>
+                {
+                    public VolumeArchetypeExtensionTest0438 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0438();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0439 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0439>
+                {
+                    public VolumeArchetypeExtensionTest0439 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0439();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0440 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0440>
+                {
+                    public VolumeArchetypeExtensionTest0440 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0440();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0441 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0441>
+                {
+                    public VolumeArchetypeExtensionTest0441 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0441();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0442 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0442>
+                {
+                    public VolumeArchetypeExtensionTest0442 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0442();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0443 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0443>
+                {
+                    public VolumeArchetypeExtensionTest0443 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0443();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0444 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0444>
+                {
+                    public VolumeArchetypeExtensionTest0444 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0444();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0445 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0445>
+                {
+                    public VolumeArchetypeExtensionTest0445 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0445();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0446 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0446>
+                {
+                    public VolumeArchetypeExtensionTest0446 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0446();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0447 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0447>
+                {
+                    public VolumeArchetypeExtensionTest0447 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0447();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0448 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0448>
+                {
+                    public VolumeArchetypeExtensionTest0448 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0448();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0449 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0449>
+                {
+                    public VolumeArchetypeExtensionTest0449 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0449();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0450 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0450>
+                {
+                    public VolumeArchetypeExtensionTest0450 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0450();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0451 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0451>
+                {
+                    public VolumeArchetypeExtensionTest0451 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0451();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0452 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0452>
+                {
+                    public VolumeArchetypeExtensionTest0452 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0452();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0453 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0453>
+                {
+                    public VolumeArchetypeExtensionTest0453 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0453();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0454 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0454>
+                {
+                    public VolumeArchetypeExtensionTest0454 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0454();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0455 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0455>
+                {
+                    public VolumeArchetypeExtensionTest0455 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0455();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0456 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0456>
+                {
+                    public VolumeArchetypeExtensionTest0456 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0456();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0457 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0457>
+                {
+                    public VolumeArchetypeExtensionTest0457 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0457();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0458 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0458>
+                {
+                    public VolumeArchetypeExtensionTest0458 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0458();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0459 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0459>
+                {
+                    public VolumeArchetypeExtensionTest0459 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0459();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0460 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0460>
+                {
+                    public VolumeArchetypeExtensionTest0460 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0460();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0461 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0461>
+                {
+                    public VolumeArchetypeExtensionTest0461 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0461();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0462 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0462>
+                {
+                    public VolumeArchetypeExtensionTest0462 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0462();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0463 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0463>
+                {
+                    public VolumeArchetypeExtensionTest0463 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0463();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0464 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0464>
+                {
+                    public VolumeArchetypeExtensionTest0464 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0464();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0465 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0465>
+                {
+                    public VolumeArchetypeExtensionTest0465 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0465();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0466 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0466>
+                {
+                    public VolumeArchetypeExtensionTest0466 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0466();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0467 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0467>
+                {
+                    public VolumeArchetypeExtensionTest0467 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0467();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0468 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0468>
+                {
+                    public VolumeArchetypeExtensionTest0468 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0468();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0469 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0469>
+                {
+                    public VolumeArchetypeExtensionTest0469 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0469();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0470 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0470>
+                {
+                    public VolumeArchetypeExtensionTest0470 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0470();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0471 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0471>
+                {
+                    public VolumeArchetypeExtensionTest0471 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0471();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0472 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0472>
+                {
+                    public VolumeArchetypeExtensionTest0472 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0472();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0473 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0473>
+                {
+                    public VolumeArchetypeExtensionTest0473 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0473();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0474 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0474>
+                {
+                    public VolumeArchetypeExtensionTest0474 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0474();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0475 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0475>
+                {
+                    public VolumeArchetypeExtensionTest0475 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0475();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0476 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0476>
+                {
+                    public VolumeArchetypeExtensionTest0476 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0476();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0477 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0477>
+                {
+                    public VolumeArchetypeExtensionTest0477 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0477();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0478 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0478>
+                {
+                    public VolumeArchetypeExtensionTest0478 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0478();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0479 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0479>
+                {
+                    public VolumeArchetypeExtensionTest0479 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0479();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0480 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0480>
+                {
+                    public VolumeArchetypeExtensionTest0480 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0480();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0481 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0481>
+                {
+                    public VolumeArchetypeExtensionTest0481 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0481();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0482 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0482>
+                {
+                    public VolumeArchetypeExtensionTest0482 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0482();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0483 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0483>
+                {
+                    public VolumeArchetypeExtensionTest0483 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0483();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0484 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0484>
+                {
+                    public VolumeArchetypeExtensionTest0484 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0484();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0485 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0485>
+                {
+                    public VolumeArchetypeExtensionTest0485 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0485();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0486 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0486>
+                {
+                    public VolumeArchetypeExtensionTest0486 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0486();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0487 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0487>
+                {
+                    public VolumeArchetypeExtensionTest0487 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0487();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0488 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0488>
+                {
+                    public VolumeArchetypeExtensionTest0488 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0488();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0489 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0489>
+                {
+                    public VolumeArchetypeExtensionTest0489 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0489();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0490 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0490>
+                {
+                    public VolumeArchetypeExtensionTest0490 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0490();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0491 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0491>
+                {
+                    public VolumeArchetypeExtensionTest0491 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0491();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0492 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0492>
+                {
+                    public VolumeArchetypeExtensionTest0492 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0492();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0493 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0493>
+                {
+                    public VolumeArchetypeExtensionTest0493 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0493();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0494 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0494>
+                {
+                    public VolumeArchetypeExtensionTest0494 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0494();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0495 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0495>
+                {
+                    public VolumeArchetypeExtensionTest0495 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0495();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0496 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0496>
+                {
+                    public VolumeArchetypeExtensionTest0496 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0496();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0497 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0497>
+                {
+                    public VolumeArchetypeExtensionTest0497 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0497();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0498 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0498>
+                {
+                    public VolumeArchetypeExtensionTest0498 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0498();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0499 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0499>
+                {
+                    public VolumeArchetypeExtensionTest0499 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0499();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0500 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0500>
+                {
+                    public VolumeArchetypeExtensionTest0500 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0500();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0501 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0501>
+                {
+                    public VolumeArchetypeExtensionTest0501 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0501();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0502 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0502>
+                {
+                    public VolumeArchetypeExtensionTest0502 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0502();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0503 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0503>
+                {
+                    public VolumeArchetypeExtensionTest0503 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0503();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0504 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0504>
+                {
+                    public VolumeArchetypeExtensionTest0504 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0504();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0505 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0505>
+                {
+                    public VolumeArchetypeExtensionTest0505 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0505();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0506 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0506>
+                {
+                    public VolumeArchetypeExtensionTest0506 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0506();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0507 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0507>
+                {
+                    public VolumeArchetypeExtensionTest0507 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0507();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0508 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0508>
+                {
+                    public VolumeArchetypeExtensionTest0508 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0508();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0509 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0509>
+                {
+                    public VolumeArchetypeExtensionTest0509 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0509();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0510 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0510>
+                {
+                    public VolumeArchetypeExtensionTest0510 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0510();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0511 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0511>
+                {
+                    public VolumeArchetypeExtensionTest0511 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0511();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0512 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0512>
+                {
+                    public VolumeArchetypeExtensionTest0512 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0512();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0513 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0513>
+                {
+                    public VolumeArchetypeExtensionTest0513 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0513();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0514 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0514>
+                {
+                    public VolumeArchetypeExtensionTest0514 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0514();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0515 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0515>
+                {
+                    public VolumeArchetypeExtensionTest0515 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0515();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0516 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0516>
+                {
+                    public VolumeArchetypeExtensionTest0516 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0516();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0517 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0517>
+                {
+                    public VolumeArchetypeExtensionTest0517 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0517();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0518 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0518>
+                {
+                    public VolumeArchetypeExtensionTest0518 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0518();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0519 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0519>
+                {
+                    public VolumeArchetypeExtensionTest0519 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0519();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0520 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0520>
+                {
+                    public VolumeArchetypeExtensionTest0520 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0520();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0521 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0521>
+                {
+                    public VolumeArchetypeExtensionTest0521 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0521();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0522 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0522>
+                {
+                    public VolumeArchetypeExtensionTest0522 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0522();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0523 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0523>
+                {
+                    public VolumeArchetypeExtensionTest0523 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0523();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0524 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0524>
+                {
+                    public VolumeArchetypeExtensionTest0524 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0524();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0525 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0525>
+                {
+                    public VolumeArchetypeExtensionTest0525 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0525();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0526 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0526>
+                {
+                    public VolumeArchetypeExtensionTest0526 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0526();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0527 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0527>
+                {
+                    public VolumeArchetypeExtensionTest0527 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0527();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0528 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0528>
+                {
+                    public VolumeArchetypeExtensionTest0528 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0528();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0529 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0529>
+                {
+                    public VolumeArchetypeExtensionTest0529 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0529();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0530 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0530>
+                {
+                    public VolumeArchetypeExtensionTest0530 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0530();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0531 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0531>
+                {
+                    public VolumeArchetypeExtensionTest0531 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0531();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0532 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0532>
+                {
+                    public VolumeArchetypeExtensionTest0532 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0532();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0533 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0533>
+                {
+                    public VolumeArchetypeExtensionTest0533 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0533();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0534 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0534>
+                {
+                    public VolumeArchetypeExtensionTest0534 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0534();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0535 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0535>
+                {
+                    public VolumeArchetypeExtensionTest0535 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0535();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0536 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0536>
+                {
+                    public VolumeArchetypeExtensionTest0536 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0536();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0537 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0537>
+                {
+                    public VolumeArchetypeExtensionTest0537 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0537();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0538 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0538>
+                {
+                    public VolumeArchetypeExtensionTest0538 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0538();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0539 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0539>
+                {
+                    public VolumeArchetypeExtensionTest0539 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0539();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0540 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0540>
+                {
+                    public VolumeArchetypeExtensionTest0540 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0540();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0541 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0541>
+                {
+                    public VolumeArchetypeExtensionTest0541 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0541();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0542 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0542>
+                {
+                    public VolumeArchetypeExtensionTest0542 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0542();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0543 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0543>
+                {
+                    public VolumeArchetypeExtensionTest0543 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0543();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0544 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0544>
+                {
+                    public VolumeArchetypeExtensionTest0544 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0544();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0545 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0545>
+                {
+                    public VolumeArchetypeExtensionTest0545 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0545();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0546 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0546>
+                {
+                    public VolumeArchetypeExtensionTest0546 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0546();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0547 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0547>
+                {
+                    public VolumeArchetypeExtensionTest0547 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0547();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0548 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0548>
+                {
+                    public VolumeArchetypeExtensionTest0548 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0548();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0549 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0549>
+                {
+                    public VolumeArchetypeExtensionTest0549 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0549();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0550 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0550>
+                {
+                    public VolumeArchetypeExtensionTest0550 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0550();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0551 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0551>
+                {
+                    public VolumeArchetypeExtensionTest0551 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0551();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0552 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0552>
+                {
+                    public VolumeArchetypeExtensionTest0552 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0552();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0553 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0553>
+                {
+                    public VolumeArchetypeExtensionTest0553 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0553();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0554 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0554>
+                {
+                    public VolumeArchetypeExtensionTest0554 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0554();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0555 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0555>
+                {
+                    public VolumeArchetypeExtensionTest0555 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0555();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0556 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0556>
+                {
+                    public VolumeArchetypeExtensionTest0556 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0556();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0557 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0557>
+                {
+                    public VolumeArchetypeExtensionTest0557 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0557();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0558 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0558>
+                {
+                    public VolumeArchetypeExtensionTest0558 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0558();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0559 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0559>
+                {
+                    public VolumeArchetypeExtensionTest0559 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0559();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0560 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0560>
+                {
+                    public VolumeArchetypeExtensionTest0560 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0560();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0561 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0561>
+                {
+                    public VolumeArchetypeExtensionTest0561 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0561();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0562 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0562>
+                {
+                    public VolumeArchetypeExtensionTest0562 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0562();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0563 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0563>
+                {
+                    public VolumeArchetypeExtensionTest0563 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0563();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0564 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0564>
+                {
+                    public VolumeArchetypeExtensionTest0564 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0564();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0565 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0565>
+                {
+                    public VolumeArchetypeExtensionTest0565 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0565();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0566 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0566>
+                {
+                    public VolumeArchetypeExtensionTest0566 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0566();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0567 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0567>
+                {
+                    public VolumeArchetypeExtensionTest0567 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0567();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0568 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0568>
+                {
+                    public VolumeArchetypeExtensionTest0568 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0568();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0569 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0569>
+                {
+                    public VolumeArchetypeExtensionTest0569 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0569();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0570 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0570>
+                {
+                    public VolumeArchetypeExtensionTest0570 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0570();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0571 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0571>
+                {
+                    public VolumeArchetypeExtensionTest0571 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0571();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0572 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0572>
+                {
+                    public VolumeArchetypeExtensionTest0572 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0572();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0573 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0573>
+                {
+                    public VolumeArchetypeExtensionTest0573 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0573();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0574 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0574>
+                {
+                    public VolumeArchetypeExtensionTest0574 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0574();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0575 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0575>
+                {
+                    public VolumeArchetypeExtensionTest0575 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0575();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0576 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0576>
+                {
+                    public VolumeArchetypeExtensionTest0576 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0576();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0577 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0577>
+                {
+                    public VolumeArchetypeExtensionTest0577 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0577();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0578 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0578>
+                {
+                    public VolumeArchetypeExtensionTest0578 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0578();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0579 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0579>
+                {
+                    public VolumeArchetypeExtensionTest0579 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0579();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0580 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0580>
+                {
+                    public VolumeArchetypeExtensionTest0580 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0580();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0581 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0581>
+                {
+                    public VolumeArchetypeExtensionTest0581 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0581();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0582 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0582>
+                {
+                    public VolumeArchetypeExtensionTest0582 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0582();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0583 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0583>
+                {
+                    public VolumeArchetypeExtensionTest0583 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0583();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0584 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0584>
+                {
+                    public VolumeArchetypeExtensionTest0584 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0584();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0585 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0585>
+                {
+                    public VolumeArchetypeExtensionTest0585 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0585();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0586 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0586>
+                {
+                    public VolumeArchetypeExtensionTest0586 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0586();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0587 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0587>
+                {
+                    public VolumeArchetypeExtensionTest0587 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0587();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0588 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0588>
+                {
+                    public VolumeArchetypeExtensionTest0588 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0588();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0589 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0589>
+                {
+                    public VolumeArchetypeExtensionTest0589 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0589();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0590 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0590>
+                {
+                    public VolumeArchetypeExtensionTest0590 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0590();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0591 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0591>
+                {
+                    public VolumeArchetypeExtensionTest0591 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0591();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0592 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0592>
+                {
+                    public VolumeArchetypeExtensionTest0592 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0592();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0593 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0593>
+                {
+                    public VolumeArchetypeExtensionTest0593 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0593();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0594 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0594>
+                {
+                    public VolumeArchetypeExtensionTest0594 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0594();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0595 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0595>
+                {
+                    public VolumeArchetypeExtensionTest0595 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0595();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0596 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0596>
+                {
+                    public VolumeArchetypeExtensionTest0596 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0596();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0597 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0597>
+                {
+                    public VolumeArchetypeExtensionTest0597 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0597();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0598 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0598>
+                {
+                    public VolumeArchetypeExtensionTest0598 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0598();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0599 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0599>
+                {
+                    public VolumeArchetypeExtensionTest0599 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0599();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0600 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0600>
+                {
+                    public VolumeArchetypeExtensionTest0600 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0600();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0601 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0601>
+                {
+                    public VolumeArchetypeExtensionTest0601 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0601();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0602 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0602>
+                {
+                    public VolumeArchetypeExtensionTest0602 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0602();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0603 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0603>
+                {
+                    public VolumeArchetypeExtensionTest0603 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0603();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0604 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0604>
+                {
+                    public VolumeArchetypeExtensionTest0604 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0604();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0605 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0605>
+                {
+                    public VolumeArchetypeExtensionTest0605 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0605();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0606 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0606>
+                {
+                    public VolumeArchetypeExtensionTest0606 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0606();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0607 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0607>
+                {
+                    public VolumeArchetypeExtensionTest0607 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0607();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0608 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0608>
+                {
+                    public VolumeArchetypeExtensionTest0608 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0608();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0609 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0609>
+                {
+                    public VolumeArchetypeExtensionTest0609 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0609();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0610 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0610>
+                {
+                    public VolumeArchetypeExtensionTest0610 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0610();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0611 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0611>
+                {
+                    public VolumeArchetypeExtensionTest0611 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0611();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0612 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0612>
+                {
+                    public VolumeArchetypeExtensionTest0612 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0612();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0613 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0613>
+                {
+                    public VolumeArchetypeExtensionTest0613 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0613();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0614 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0614>
+                {
+                    public VolumeArchetypeExtensionTest0614 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0614();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0615 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0615>
+                {
+                    public VolumeArchetypeExtensionTest0615 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0615();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0616 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0616>
+                {
+                    public VolumeArchetypeExtensionTest0616 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0616();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0617 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0617>
+                {
+                    public VolumeArchetypeExtensionTest0617 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0617();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0618 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0618>
+                {
+                    public VolumeArchetypeExtensionTest0618 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0618();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0619 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0619>
+                {
+                    public VolumeArchetypeExtensionTest0619 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0619();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0620 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0620>
+                {
+                    public VolumeArchetypeExtensionTest0620 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0620();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0621 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0621>
+                {
+                    public VolumeArchetypeExtensionTest0621 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0621();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0622 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0622>
+                {
+                    public VolumeArchetypeExtensionTest0622 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0622();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0623 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0623>
+                {
+                    public VolumeArchetypeExtensionTest0623 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0623();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0624 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0624>
+                {
+                    public VolumeArchetypeExtensionTest0624 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0624();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0625 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0625>
+                {
+                    public VolumeArchetypeExtensionTest0625 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0625();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0626 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0626>
+                {
+                    public VolumeArchetypeExtensionTest0626 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0626();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0627 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0627>
+                {
+                    public VolumeArchetypeExtensionTest0627 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0627();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0628 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0628>
+                {
+                    public VolumeArchetypeExtensionTest0628 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0628();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0629 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0629>
+                {
+                    public VolumeArchetypeExtensionTest0629 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0629();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0630 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0630>
+                {
+                    public VolumeArchetypeExtensionTest0630 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0630();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0631 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0631>
+                {
+                    public VolumeArchetypeExtensionTest0631 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0631();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0632 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0632>
+                {
+                    public VolumeArchetypeExtensionTest0632 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0632();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0633 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0633>
+                {
+                    public VolumeArchetypeExtensionTest0633 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0633();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0634 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0634>
+                {
+                    public VolumeArchetypeExtensionTest0634 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0634();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0635 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0635>
+                {
+                    public VolumeArchetypeExtensionTest0635 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0635();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0636 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0636>
+                {
+                    public VolumeArchetypeExtensionTest0636 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0636();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0637 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0637>
+                {
+                    public VolumeArchetypeExtensionTest0637 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0637();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0638 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0638>
+                {
+                    public VolumeArchetypeExtensionTest0638 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0638();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0639 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0639>
+                {
+                    public VolumeArchetypeExtensionTest0639 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0639();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0640 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0640>
+                {
+                    public VolumeArchetypeExtensionTest0640 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0640();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0641 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0641>
+                {
+                    public VolumeArchetypeExtensionTest0641 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0641();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0642 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0642>
+                {
+                    public VolumeArchetypeExtensionTest0642 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0642();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0643 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0643>
+                {
+                    public VolumeArchetypeExtensionTest0643 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0643();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0644 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0644>
+                {
+                    public VolumeArchetypeExtensionTest0644 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0644();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0645 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0645>
+                {
+                    public VolumeArchetypeExtensionTest0645 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0645();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0646 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0646>
+                {
+                    public VolumeArchetypeExtensionTest0646 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0646();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0647 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0647>
+                {
+                    public VolumeArchetypeExtensionTest0647 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0647();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0648 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0648>
+                {
+                    public VolumeArchetypeExtensionTest0648 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0648();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0649 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0649>
+                {
+                    public VolumeArchetypeExtensionTest0649 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0649();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0650 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0650>
+                {
+                    public VolumeArchetypeExtensionTest0650 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0650();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0651 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0651>
+                {
+                    public VolumeArchetypeExtensionTest0651 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0651();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0652 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0652>
+                {
+                    public VolumeArchetypeExtensionTest0652 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0652();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0653 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0653>
+                {
+                    public VolumeArchetypeExtensionTest0653 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0653();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0654 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0654>
+                {
+                    public VolumeArchetypeExtensionTest0654 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0654();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0655 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0655>
+                {
+                    public VolumeArchetypeExtensionTest0655 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0655();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0656 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0656>
+                {
+                    public VolumeArchetypeExtensionTest0656 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0656();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0657 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0657>
+                {
+                    public VolumeArchetypeExtensionTest0657 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0657();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0658 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0658>
+                {
+                    public VolumeArchetypeExtensionTest0658 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0658();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0659 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0659>
+                {
+                    public VolumeArchetypeExtensionTest0659 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0659();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0660 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0660>
+                {
+                    public VolumeArchetypeExtensionTest0660 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0660();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0661 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0661>
+                {
+                    public VolumeArchetypeExtensionTest0661 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0661();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0662 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0662>
+                {
+                    public VolumeArchetypeExtensionTest0662 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0662();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0663 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0663>
+                {
+                    public VolumeArchetypeExtensionTest0663 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0663();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0664 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0664>
+                {
+                    public VolumeArchetypeExtensionTest0664 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0664();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0665 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0665>
+                {
+                    public VolumeArchetypeExtensionTest0665 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0665();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0666 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0666>
+                {
+                    public VolumeArchetypeExtensionTest0666 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0666();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0667 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0667>
+                {
+                    public VolumeArchetypeExtensionTest0667 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0667();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0668 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0668>
+                {
+                    public VolumeArchetypeExtensionTest0668 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0668();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0669 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0669>
+                {
+                    public VolumeArchetypeExtensionTest0669 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0669();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0670 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0670>
+                {
+                    public VolumeArchetypeExtensionTest0670 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0670();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0671 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0671>
+                {
+                    public VolumeArchetypeExtensionTest0671 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0671();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0672 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0672>
+                {
+                    public VolumeArchetypeExtensionTest0672 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0672();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0673 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0673>
+                {
+                    public VolumeArchetypeExtensionTest0673 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0673();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0674 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0674>
+                {
+                    public VolumeArchetypeExtensionTest0674 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0674();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0675 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0675>
+                {
+                    public VolumeArchetypeExtensionTest0675 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0675();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0676 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0676>
+                {
+                    public VolumeArchetypeExtensionTest0676 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0676();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0677 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0677>
+                {
+                    public VolumeArchetypeExtensionTest0677 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0677();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0678 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0678>
+                {
+                    public VolumeArchetypeExtensionTest0678 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0678();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0679 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0679>
+                {
+                    public VolumeArchetypeExtensionTest0679 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0679();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0680 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0680>
+                {
+                    public VolumeArchetypeExtensionTest0680 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0680();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0681 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0681>
+                {
+                    public VolumeArchetypeExtensionTest0681 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0681();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0682 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0682>
+                {
+                    public VolumeArchetypeExtensionTest0682 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0682();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0683 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0683>
+                {
+                    public VolumeArchetypeExtensionTest0683 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0683();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0684 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0684>
+                {
+                    public VolumeArchetypeExtensionTest0684 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0684();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0685 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0685>
+                {
+                    public VolumeArchetypeExtensionTest0685 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0685();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0686 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0686>
+                {
+                    public VolumeArchetypeExtensionTest0686 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0686();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0687 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0687>
+                {
+                    public VolumeArchetypeExtensionTest0687 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0687();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0688 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0688>
+                {
+                    public VolumeArchetypeExtensionTest0688 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0688();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0689 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0689>
+                {
+                    public VolumeArchetypeExtensionTest0689 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0689();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0690 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0690>
+                {
+                    public VolumeArchetypeExtensionTest0690 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0690();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0691 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0691>
+                {
+                    public VolumeArchetypeExtensionTest0691 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0691();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0692 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0692>
+                {
+                    public VolumeArchetypeExtensionTest0692 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0692();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0693 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0693>
+                {
+                    public VolumeArchetypeExtensionTest0693 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0693();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0694 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0694>
+                {
+                    public VolumeArchetypeExtensionTest0694 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0694();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0695 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0695>
+                {
+                    public VolumeArchetypeExtensionTest0695 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0695();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0696 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0696>
+                {
+                    public VolumeArchetypeExtensionTest0696 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0696();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0697 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0697>
+                {
+                    public VolumeArchetypeExtensionTest0697 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0697();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0698 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0698>
+                {
+                    public VolumeArchetypeExtensionTest0698 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0698();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0699 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0699>
+                {
+                    public VolumeArchetypeExtensionTest0699 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0699();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0700 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0700>
+                {
+                    public VolumeArchetypeExtensionTest0700 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0700();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0701 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0701>
+                {
+                    public VolumeArchetypeExtensionTest0701 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0701();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0702 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0702>
+                {
+                    public VolumeArchetypeExtensionTest0702 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0702();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0703 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0703>
+                {
+                    public VolumeArchetypeExtensionTest0703 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0703();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0704 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0704>
+                {
+                    public VolumeArchetypeExtensionTest0704 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0704();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0705 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0705>
+                {
+                    public VolumeArchetypeExtensionTest0705 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0705();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0706 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0706>
+                {
+                    public VolumeArchetypeExtensionTest0706 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0706();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0707 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0707>
+                {
+                    public VolumeArchetypeExtensionTest0707 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0707();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0708 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0708>
+                {
+                    public VolumeArchetypeExtensionTest0708 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0708();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0709 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0709>
+                {
+                    public VolumeArchetypeExtensionTest0709 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0709();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0710 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0710>
+                {
+                    public VolumeArchetypeExtensionTest0710 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0710();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0711 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0711>
+                {
+                    public VolumeArchetypeExtensionTest0711 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0711();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0712 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0712>
+                {
+                    public VolumeArchetypeExtensionTest0712 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0712();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0713 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0713>
+                {
+                    public VolumeArchetypeExtensionTest0713 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0713();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0714 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0714>
+                {
+                    public VolumeArchetypeExtensionTest0714 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0714();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0715 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0715>
+                {
+                    public VolumeArchetypeExtensionTest0715 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0715();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0716 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0716>
+                {
+                    public VolumeArchetypeExtensionTest0716 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0716();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0717 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0717>
+                {
+                    public VolumeArchetypeExtensionTest0717 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0717();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0718 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0718>
+                {
+                    public VolumeArchetypeExtensionTest0718 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0718();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0719 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0719>
+                {
+                    public VolumeArchetypeExtensionTest0719 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0719();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0720 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0720>
+                {
+                    public VolumeArchetypeExtensionTest0720 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0720();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0721 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0721>
+                {
+                    public VolumeArchetypeExtensionTest0721 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0721();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0722 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0722>
+                {
+                    public VolumeArchetypeExtensionTest0722 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0722();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0723 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0723>
+                {
+                    public VolumeArchetypeExtensionTest0723 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0723();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0724 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0724>
+                {
+                    public VolumeArchetypeExtensionTest0724 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0724();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0725 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0725>
+                {
+                    public VolumeArchetypeExtensionTest0725 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0725();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0726 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0726>
+                {
+                    public VolumeArchetypeExtensionTest0726 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0726();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0727 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0727>
+                {
+                    public VolumeArchetypeExtensionTest0727 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0727();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0728 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0728>
+                {
+                    public VolumeArchetypeExtensionTest0728 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0728();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0729 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0729>
+                {
+                    public VolumeArchetypeExtensionTest0729 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0729();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0730 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0730>
+                {
+                    public VolumeArchetypeExtensionTest0730 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0730();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0731 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0731>
+                {
+                    public VolumeArchetypeExtensionTest0731 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0731();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0732 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0732>
+                {
+                    public VolumeArchetypeExtensionTest0732 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0732();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0733 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0733>
+                {
+                    public VolumeArchetypeExtensionTest0733 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0733();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0734 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0734>
+                {
+                    public VolumeArchetypeExtensionTest0734 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0734();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0735 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0735>
+                {
+                    public VolumeArchetypeExtensionTest0735 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0735();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0736 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0736>
+                {
+                    public VolumeArchetypeExtensionTest0736 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0736();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0737 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0737>
+                {
+                    public VolumeArchetypeExtensionTest0737 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0737();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0738 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0738>
+                {
+                    public VolumeArchetypeExtensionTest0738 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0738();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0739 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0739>
+                {
+                    public VolumeArchetypeExtensionTest0739 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0739();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0740 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0740>
+                {
+                    public VolumeArchetypeExtensionTest0740 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0740();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0741 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0741>
+                {
+                    public VolumeArchetypeExtensionTest0741 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0741();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0742 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0742>
+                {
+                    public VolumeArchetypeExtensionTest0742 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0742();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0743 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0743>
+                {
+                    public VolumeArchetypeExtensionTest0743 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0743();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0744 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0744>
+                {
+                    public VolumeArchetypeExtensionTest0744 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0744();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0745 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0745>
+                {
+                    public VolumeArchetypeExtensionTest0745 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0745();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0746 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0746>
+                {
+                    public VolumeArchetypeExtensionTest0746 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0746();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0747 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0747>
+                {
+                    public VolumeArchetypeExtensionTest0747 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0747();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0748 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0748>
+                {
+                    public VolumeArchetypeExtensionTest0748 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0748();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0749 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0749>
+                {
+                    public VolumeArchetypeExtensionTest0749 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0749();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0750 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0750>
+                {
+                    public VolumeArchetypeExtensionTest0750 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0750();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0751 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0751>
+                {
+                    public VolumeArchetypeExtensionTest0751 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0751();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0752 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0752>
+                {
+                    public VolumeArchetypeExtensionTest0752 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0752();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0753 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0753>
+                {
+                    public VolumeArchetypeExtensionTest0753 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0753();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0754 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0754>
+                {
+                    public VolumeArchetypeExtensionTest0754 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0754();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0755 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0755>
+                {
+                    public VolumeArchetypeExtensionTest0755 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0755();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0756 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0756>
+                {
+                    public VolumeArchetypeExtensionTest0756 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0756();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0757 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0757>
+                {
+                    public VolumeArchetypeExtensionTest0757 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0757();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0758 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0758>
+                {
+                    public VolumeArchetypeExtensionTest0758 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0758();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0759 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0759>
+                {
+                    public VolumeArchetypeExtensionTest0759 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0759();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0760 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0760>
+                {
+                    public VolumeArchetypeExtensionTest0760 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0760();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0761 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0761>
+                {
+                    public VolumeArchetypeExtensionTest0761 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0761();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0762 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0762>
+                {
+                    public VolumeArchetypeExtensionTest0762 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0762();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0763 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0763>
+                {
+                    public VolumeArchetypeExtensionTest0763 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0763();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0764 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0764>
+                {
+                    public VolumeArchetypeExtensionTest0764 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0764();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0765 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0765>
+                {
+                    public VolumeArchetypeExtensionTest0765 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0765();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0766 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0766>
+                {
+                    public VolumeArchetypeExtensionTest0766 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0766();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0767 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0767>
+                {
+                    public VolumeArchetypeExtensionTest0767 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0767();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0768 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0768>
+                {
+                    public VolumeArchetypeExtensionTest0768 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0768();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0769 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0769>
+                {
+                    public VolumeArchetypeExtensionTest0769 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0769();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0770 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0770>
+                {
+                    public VolumeArchetypeExtensionTest0770 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0770();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0771 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0771>
+                {
+                    public VolumeArchetypeExtensionTest0771 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0771();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0772 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0772>
+                {
+                    public VolumeArchetypeExtensionTest0772 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0772();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0773 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0773>
+                {
+                    public VolumeArchetypeExtensionTest0773 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0773();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0774 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0774>
+                {
+                    public VolumeArchetypeExtensionTest0774 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0774();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0775 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0775>
+                {
+                    public VolumeArchetypeExtensionTest0775 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0775();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0776 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0776>
+                {
+                    public VolumeArchetypeExtensionTest0776 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0776();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0777 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0777>
+                {
+                    public VolumeArchetypeExtensionTest0777 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0777();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0778 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0778>
+                {
+                    public VolumeArchetypeExtensionTest0778 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0778();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0779 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0779>
+                {
+                    public VolumeArchetypeExtensionTest0779 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0779();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0780 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0780>
+                {
+                    public VolumeArchetypeExtensionTest0780 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0780();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0781 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0781>
+                {
+                    public VolumeArchetypeExtensionTest0781 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0781();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0782 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0782>
+                {
+                    public VolumeArchetypeExtensionTest0782 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0782();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0783 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0783>
+                {
+                    public VolumeArchetypeExtensionTest0783 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0783();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0784 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0784>
+                {
+                    public VolumeArchetypeExtensionTest0784 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0784();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0785 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0785>
+                {
+                    public VolumeArchetypeExtensionTest0785 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0785();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0786 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0786>
+                {
+                    public VolumeArchetypeExtensionTest0786 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0786();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0787 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0787>
+                {
+                    public VolumeArchetypeExtensionTest0787 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0787();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0788 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0788>
+                {
+                    public VolumeArchetypeExtensionTest0788 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0788();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0789 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0789>
+                {
+                    public VolumeArchetypeExtensionTest0789 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0789();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0790 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0790>
+                {
+                    public VolumeArchetypeExtensionTest0790 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0790();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0791 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0791>
+                {
+                    public VolumeArchetypeExtensionTest0791 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0791();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0792 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0792>
+                {
+                    public VolumeArchetypeExtensionTest0792 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0792();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0793 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0793>
+                {
+                    public VolumeArchetypeExtensionTest0793 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0793();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0794 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0794>
+                {
+                    public VolumeArchetypeExtensionTest0794 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0794();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0795 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0795>
+                {
+                    public VolumeArchetypeExtensionTest0795 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0795();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0796 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0796>
+                {
+                    public VolumeArchetypeExtensionTest0796 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0796();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0797 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0797>
+                {
+                    public VolumeArchetypeExtensionTest0797 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0797();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0798 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0798>
+                {
+                    public VolumeArchetypeExtensionTest0798 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0798();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0799 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0799>
+                {
+                    public VolumeArchetypeExtensionTest0799 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0799();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0800 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0800>
+                {
+                    public VolumeArchetypeExtensionTest0800 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0800();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0801 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0801>
+                {
+                    public VolumeArchetypeExtensionTest0801 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0801();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0802 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0802>
+                {
+                    public VolumeArchetypeExtensionTest0802 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0802();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0803 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0803>
+                {
+                    public VolumeArchetypeExtensionTest0803 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0803();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0804 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0804>
+                {
+                    public VolumeArchetypeExtensionTest0804 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0804();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0805 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0805>
+                {
+                    public VolumeArchetypeExtensionTest0805 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0805();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0806 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0806>
+                {
+                    public VolumeArchetypeExtensionTest0806 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0806();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0807 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0807>
+                {
+                    public VolumeArchetypeExtensionTest0807 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0807();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0808 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0808>
+                {
+                    public VolumeArchetypeExtensionTest0808 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0808();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0809 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0809>
+                {
+                    public VolumeArchetypeExtensionTest0809 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0809();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0810 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0810>
+                {
+                    public VolumeArchetypeExtensionTest0810 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0810();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0811 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0811>
+                {
+                    public VolumeArchetypeExtensionTest0811 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0811();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0812 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0812>
+                {
+                    public VolumeArchetypeExtensionTest0812 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0812();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0813 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0813>
+                {
+                    public VolumeArchetypeExtensionTest0813 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0813();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0814 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0814>
+                {
+                    public VolumeArchetypeExtensionTest0814 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0814();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0815 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0815>
+                {
+                    public VolumeArchetypeExtensionTest0815 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0815();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0816 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0816>
+                {
+                    public VolumeArchetypeExtensionTest0816 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0816();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0817 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0817>
+                {
+                    public VolumeArchetypeExtensionTest0817 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0817();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0818 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0818>
+                {
+                    public VolumeArchetypeExtensionTest0818 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0818();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0819 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0819>
+                {
+                    public VolumeArchetypeExtensionTest0819 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0819();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0820 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0820>
+                {
+                    public VolumeArchetypeExtensionTest0820 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0820();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0821 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0821>
+                {
+                    public VolumeArchetypeExtensionTest0821 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0821();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0822 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0822>
+                {
+                    public VolumeArchetypeExtensionTest0822 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0822();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0823 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0823>
+                {
+                    public VolumeArchetypeExtensionTest0823 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0823();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0824 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0824>
+                {
+                    public VolumeArchetypeExtensionTest0824 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0824();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0825 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0825>
+                {
+                    public VolumeArchetypeExtensionTest0825 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0825();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0826 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0826>
+                {
+                    public VolumeArchetypeExtensionTest0826 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0826();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0827 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0827>
+                {
+                    public VolumeArchetypeExtensionTest0827 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0827();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0828 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0828>
+                {
+                    public VolumeArchetypeExtensionTest0828 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0828();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0829 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0829>
+                {
+                    public VolumeArchetypeExtensionTest0829 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0829();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0830 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0830>
+                {
+                    public VolumeArchetypeExtensionTest0830 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0830();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0831 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0831>
+                {
+                    public VolumeArchetypeExtensionTest0831 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0831();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0832 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0832>
+                {
+                    public VolumeArchetypeExtensionTest0832 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0832();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0833 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0833>
+                {
+                    public VolumeArchetypeExtensionTest0833 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0833();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0834 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0834>
+                {
+                    public VolumeArchetypeExtensionTest0834 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0834();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0835 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0835>
+                {
+                    public VolumeArchetypeExtensionTest0835 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0835();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0836 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0836>
+                {
+                    public VolumeArchetypeExtensionTest0836 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0836();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0837 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0837>
+                {
+                    public VolumeArchetypeExtensionTest0837 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0837();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0838 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0838>
+                {
+                    public VolumeArchetypeExtensionTest0838 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0838();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0839 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0839>
+                {
+                    public VolumeArchetypeExtensionTest0839 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0839();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0840 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0840>
+                {
+                    public VolumeArchetypeExtensionTest0840 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0840();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0841 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0841>
+                {
+                    public VolumeArchetypeExtensionTest0841 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0841();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0842 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0842>
+                {
+                    public VolumeArchetypeExtensionTest0842 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0842();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0843 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0843>
+                {
+                    public VolumeArchetypeExtensionTest0843 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0843();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0844 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0844>
+                {
+                    public VolumeArchetypeExtensionTest0844 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0844();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0845 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0845>
+                {
+                    public VolumeArchetypeExtensionTest0845 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0845();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0846 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0846>
+                {
+                    public VolumeArchetypeExtensionTest0846 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0846();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0847 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0847>
+                {
+                    public VolumeArchetypeExtensionTest0847 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0847();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0848 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0848>
+                {
+                    public VolumeArchetypeExtensionTest0848 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0848();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0849 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0849>
+                {
+                    public VolumeArchetypeExtensionTest0849 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0849();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0850 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0850>
+                {
+                    public VolumeArchetypeExtensionTest0850 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0850();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0851 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0851>
+                {
+                    public VolumeArchetypeExtensionTest0851 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0851();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0852 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0852>
+                {
+                    public VolumeArchetypeExtensionTest0852 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0852();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0853 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0853>
+                {
+                    public VolumeArchetypeExtensionTest0853 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0853();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0854 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0854>
+                {
+                    public VolumeArchetypeExtensionTest0854 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0854();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0855 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0855>
+                {
+                    public VolumeArchetypeExtensionTest0855 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0855();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0856 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0856>
+                {
+                    public VolumeArchetypeExtensionTest0856 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0856();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0857 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0857>
+                {
+                    public VolumeArchetypeExtensionTest0857 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0857();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0858 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0858>
+                {
+                    public VolumeArchetypeExtensionTest0858 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0858();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0859 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0859>
+                {
+                    public VolumeArchetypeExtensionTest0859 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0859();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0860 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0860>
+                {
+                    public VolumeArchetypeExtensionTest0860 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0860();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0861 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0861>
+                {
+                    public VolumeArchetypeExtensionTest0861 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0861();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0862 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0862>
+                {
+                    public VolumeArchetypeExtensionTest0862 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0862();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0863 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0863>
+                {
+                    public VolumeArchetypeExtensionTest0863 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0863();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0864 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0864>
+                {
+                    public VolumeArchetypeExtensionTest0864 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0864();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0865 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0865>
+                {
+                    public VolumeArchetypeExtensionTest0865 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0865();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0866 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0866>
+                {
+                    public VolumeArchetypeExtensionTest0866 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0866();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0867 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0867>
+                {
+                    public VolumeArchetypeExtensionTest0867 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0867();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0868 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0868>
+                {
+                    public VolumeArchetypeExtensionTest0868 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0868();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0869 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0869>
+                {
+                    public VolumeArchetypeExtensionTest0869 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0869();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0870 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0870>
+                {
+                    public VolumeArchetypeExtensionTest0870 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0870();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0871 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0871>
+                {
+                    public VolumeArchetypeExtensionTest0871 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0871();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0872 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0872>
+                {
+                    public VolumeArchetypeExtensionTest0872 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0872();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0873 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0873>
+                {
+                    public VolumeArchetypeExtensionTest0873 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0873();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0874 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0874>
+                {
+                    public VolumeArchetypeExtensionTest0874 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0874();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0875 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0875>
+                {
+                    public VolumeArchetypeExtensionTest0875 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0875();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0876 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0876>
+                {
+                    public VolumeArchetypeExtensionTest0876 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0876();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0877 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0877>
+                {
+                    public VolumeArchetypeExtensionTest0877 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0877();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0878 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0878>
+                {
+                    public VolumeArchetypeExtensionTest0878 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0878();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0879 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0879>
+                {
+                    public VolumeArchetypeExtensionTest0879 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0879();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0880 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0880>
+                {
+                    public VolumeArchetypeExtensionTest0880 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0880();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0881 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0881>
+                {
+                    public VolumeArchetypeExtensionTest0881 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0881();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0882 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0882>
+                {
+                    public VolumeArchetypeExtensionTest0882 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0882();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0883 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0883>
+                {
+                    public VolumeArchetypeExtensionTest0883 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0883();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0884 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0884>
+                {
+                    public VolumeArchetypeExtensionTest0884 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0884();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0885 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0885>
+                {
+                    public VolumeArchetypeExtensionTest0885 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0885();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0886 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0886>
+                {
+                    public VolumeArchetypeExtensionTest0886 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0886();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0887 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0887>
+                {
+                    public VolumeArchetypeExtensionTest0887 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0887();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0888 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0888>
+                {
+                    public VolumeArchetypeExtensionTest0888 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0888();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0889 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0889>
+                {
+                    public VolumeArchetypeExtensionTest0889 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0889();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0890 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0890>
+                {
+                    public VolumeArchetypeExtensionTest0890 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0890();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0891 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0891>
+                {
+                    public VolumeArchetypeExtensionTest0891 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0891();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0892 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0892>
+                {
+                    public VolumeArchetypeExtensionTest0892 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0892();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0893 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0893>
+                {
+                    public VolumeArchetypeExtensionTest0893 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0893();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0894 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0894>
+                {
+                    public VolumeArchetypeExtensionTest0894 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0894();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0895 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0895>
+                {
+                    public VolumeArchetypeExtensionTest0895 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0895();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0896 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0896>
+                {
+                    public VolumeArchetypeExtensionTest0896 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0896();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0897 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0897>
+                {
+                    public VolumeArchetypeExtensionTest0897 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0897();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0898 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0898>
+                {
+                    public VolumeArchetypeExtensionTest0898 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0898();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0899 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0899>
+                {
+                    public VolumeArchetypeExtensionTest0899 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0899();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0900 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0900>
+                {
+                    public VolumeArchetypeExtensionTest0900 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0900();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0901 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0901>
+                {
+                    public VolumeArchetypeExtensionTest0901 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0901();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0902 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0902>
+                {
+                    public VolumeArchetypeExtensionTest0902 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0902();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0903 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0903>
+                {
+                    public VolumeArchetypeExtensionTest0903 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0903();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0904 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0904>
+                {
+                    public VolumeArchetypeExtensionTest0904 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0904();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0905 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0905>
+                {
+                    public VolumeArchetypeExtensionTest0905 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0905();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0906 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0906>
+                {
+                    public VolumeArchetypeExtensionTest0906 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0906();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0907 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0907>
+                {
+                    public VolumeArchetypeExtensionTest0907 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0907();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0908 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0908>
+                {
+                    public VolumeArchetypeExtensionTest0908 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0908();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0909 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0909>
+                {
+                    public VolumeArchetypeExtensionTest0909 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0909();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0910 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0910>
+                {
+                    public VolumeArchetypeExtensionTest0910 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0910();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0911 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0911>
+                {
+                    public VolumeArchetypeExtensionTest0911 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0911();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0912 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0912>
+                {
+                    public VolumeArchetypeExtensionTest0912 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0912();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0913 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0913>
+                {
+                    public VolumeArchetypeExtensionTest0913 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0913();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0914 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0914>
+                {
+                    public VolumeArchetypeExtensionTest0914 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0914();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0915 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0915>
+                {
+                    public VolumeArchetypeExtensionTest0915 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0915();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0916 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0916>
+                {
+                    public VolumeArchetypeExtensionTest0916 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0916();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0917 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0917>
+                {
+                    public VolumeArchetypeExtensionTest0917 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0917();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0918 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0918>
+                {
+                    public VolumeArchetypeExtensionTest0918 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0918();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0919 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0919>
+                {
+                    public VolumeArchetypeExtensionTest0919 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0919();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0920 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0920>
+                {
+                    public VolumeArchetypeExtensionTest0920 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0920();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0921 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0921>
+                {
+                    public VolumeArchetypeExtensionTest0921 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0921();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0922 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0922>
+                {
+                    public VolumeArchetypeExtensionTest0922 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0922();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0923 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0923>
+                {
+                    public VolumeArchetypeExtensionTest0923 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0923();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0924 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0924>
+                {
+                    public VolumeArchetypeExtensionTest0924 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0924();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0925 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0925>
+                {
+                    public VolumeArchetypeExtensionTest0925 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0925();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0926 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0926>
+                {
+                    public VolumeArchetypeExtensionTest0926 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0926();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0927 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0927>
+                {
+                    public VolumeArchetypeExtensionTest0927 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0927();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0928 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0928>
+                {
+                    public VolumeArchetypeExtensionTest0928 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0928();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0929 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0929>
+                {
+                    public VolumeArchetypeExtensionTest0929 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0929();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0930 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0930>
+                {
+                    public VolumeArchetypeExtensionTest0930 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0930();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0931 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0931>
+                {
+                    public VolumeArchetypeExtensionTest0931 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0931();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0932 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0932>
+                {
+                    public VolumeArchetypeExtensionTest0932 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0932();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0933 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0933>
+                {
+                    public VolumeArchetypeExtensionTest0933 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0933();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0934 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0934>
+                {
+                    public VolumeArchetypeExtensionTest0934 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0934();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0935 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0935>
+                {
+                    public VolumeArchetypeExtensionTest0935 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0935();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0936 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0936>
+                {
+                    public VolumeArchetypeExtensionTest0936 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0936();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0937 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0937>
+                {
+                    public VolumeArchetypeExtensionTest0937 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0937();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0938 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0938>
+                {
+                    public VolumeArchetypeExtensionTest0938 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0938();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0939 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0939>
+                {
+                    public VolumeArchetypeExtensionTest0939 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0939();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0940 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0940>
+                {
+                    public VolumeArchetypeExtensionTest0940 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0940();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0941 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0941>
+                {
+                    public VolumeArchetypeExtensionTest0941 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0941();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0942 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0942>
+                {
+                    public VolumeArchetypeExtensionTest0942 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0942();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0943 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0943>
+                {
+                    public VolumeArchetypeExtensionTest0943 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0943();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0944 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0944>
+                {
+                    public VolumeArchetypeExtensionTest0944 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0944();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0945 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0945>
+                {
+                    public VolumeArchetypeExtensionTest0945 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0945();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0946 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0946>
+                {
+                    public VolumeArchetypeExtensionTest0946 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0946();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0947 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0947>
+                {
+                    public VolumeArchetypeExtensionTest0947 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0947();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0948 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0948>
+                {
+                    public VolumeArchetypeExtensionTest0948 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0948();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0949 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0949>
+                {
+                    public VolumeArchetypeExtensionTest0949 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0949();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0950 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0950>
+                {
+                    public VolumeArchetypeExtensionTest0950 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0950();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0951 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0951>
+                {
+                    public VolumeArchetypeExtensionTest0951 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0951();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0952 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0952>
+                {
+                    public VolumeArchetypeExtensionTest0952 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0952();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0953 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0953>
+                {
+                    public VolumeArchetypeExtensionTest0953 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0953();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0954 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0954>
+                {
+                    public VolumeArchetypeExtensionTest0954 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0954();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0955 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0955>
+                {
+                    public VolumeArchetypeExtensionTest0955 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0955();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0956 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0956>
+                {
+                    public VolumeArchetypeExtensionTest0956 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0956();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0957 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0957>
+                {
+                    public VolumeArchetypeExtensionTest0957 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0957();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0958 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0958>
+                {
+                    public VolumeArchetypeExtensionTest0958 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0958();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0959 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0959>
+                {
+                    public VolumeArchetypeExtensionTest0959 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0959();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0960 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0960>
+                {
+                    public VolumeArchetypeExtensionTest0960 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0960();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0961 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0961>
+                {
+                    public VolumeArchetypeExtensionTest0961 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0961();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0962 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0962>
+                {
+                    public VolumeArchetypeExtensionTest0962 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0962();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0963 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0963>
+                {
+                    public VolumeArchetypeExtensionTest0963 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0963();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0964 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0964>
+                {
+                    public VolumeArchetypeExtensionTest0964 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0964();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0965 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0965>
+                {
+                    public VolumeArchetypeExtensionTest0965 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0965();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0966 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0966>
+                {
+                    public VolumeArchetypeExtensionTest0966 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0966();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0967 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0967>
+                {
+                    public VolumeArchetypeExtensionTest0967 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0967();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0968 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0968>
+                {
+                    public VolumeArchetypeExtensionTest0968 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0968();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0969 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0969>
+                {
+                    public VolumeArchetypeExtensionTest0969 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0969();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0970 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0970>
+                {
+                    public VolumeArchetypeExtensionTest0970 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0970();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0971 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0971>
+                {
+                    public VolumeArchetypeExtensionTest0971 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0971();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0972 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0972>
+                {
+                    public VolumeArchetypeExtensionTest0972 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0972();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0973 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0973>
+                {
+                    public VolumeArchetypeExtensionTest0973 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0973();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0974 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0974>
+                {
+                    public VolumeArchetypeExtensionTest0974 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0974();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0975 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0975>
+                {
+                    public VolumeArchetypeExtensionTest0975 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0975();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0976 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0976>
+                {
+                    public VolumeArchetypeExtensionTest0976 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0976();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0977 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0977>
+                {
+                    public VolumeArchetypeExtensionTest0977 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0977();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0978 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0978>
+                {
+                    public VolumeArchetypeExtensionTest0978 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0978();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0979 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0979>
+                {
+                    public VolumeArchetypeExtensionTest0979 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0979();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0980 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0980>
+                {
+                    public VolumeArchetypeExtensionTest0980 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0980();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0981 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0981>
+                {
+                    public VolumeArchetypeExtensionTest0981 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0981();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0982 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0982>
+                {
+                    public VolumeArchetypeExtensionTest0982 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0982();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0983 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0983>
+                {
+                    public VolumeArchetypeExtensionTest0983 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0983();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0984 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0984>
+                {
+                    public VolumeArchetypeExtensionTest0984 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0984();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0985 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0985>
+                {
+                    public VolumeArchetypeExtensionTest0985 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0985();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0986 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0986>
+                {
+                    public VolumeArchetypeExtensionTest0986 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0986();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0987 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0987>
+                {
+                    public VolumeArchetypeExtensionTest0987 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0987();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0988 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0988>
+                {
+                    public VolumeArchetypeExtensionTest0988 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0988();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0989 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0989>
+                {
+                    public VolumeArchetypeExtensionTest0989 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0989();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0990 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0990>
+                {
+                    public VolumeArchetypeExtensionTest0990 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0990();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0991 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0991>
+                {
+                    public VolumeArchetypeExtensionTest0991 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0991();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0992 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0992>
+                {
+                    public VolumeArchetypeExtensionTest0992 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0992();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0993 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0993>
+                {
+                    public VolumeArchetypeExtensionTest0993 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0993();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0994 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0994>
+                {
+                    public VolumeArchetypeExtensionTest0994 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0994();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0995 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0995>
+                {
+                    public VolumeArchetypeExtensionTest0995 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0995();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0996 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0996>
+                {
+                    public VolumeArchetypeExtensionTest0996 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0996();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0997 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0997>
+                {
+                    public VolumeArchetypeExtensionTest0997 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0997();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0998 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0998>
+                {
+                    public VolumeArchetypeExtensionTest0998 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0998();
+                    }
+                }
+            }
+            public class VolumeArchetypeExtensionTest0999 : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<VolumeArchetypeExtensionTest0999>
+                {
+                    public VolumeArchetypeExtensionTest0999 Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new VolumeArchetypeExtensionTest0999();
+                    }
+                }
+            }
+        }
+        partial struct GetAndAddExtensionsTestAction
+        {
+            private partial void ApplyGetTo(VolumeComponentArchetype archetype, Type type)
+            {
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0000))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0000, GeneratedExtensions.VolumeArchetypeExtensionTest0000.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0001))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0001, GeneratedExtensions.VolumeArchetypeExtensionTest0001.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0002))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0002, GeneratedExtensions.VolumeArchetypeExtensionTest0002.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0003))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0003, GeneratedExtensions.VolumeArchetypeExtensionTest0003.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0004))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0004, GeneratedExtensions.VolumeArchetypeExtensionTest0004.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0005))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0005, GeneratedExtensions.VolumeArchetypeExtensionTest0005.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0006))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0006, GeneratedExtensions.VolumeArchetypeExtensionTest0006.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0007))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0007, GeneratedExtensions.VolumeArchetypeExtensionTest0007.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0008))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0008, GeneratedExtensions.VolumeArchetypeExtensionTest0008.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0009))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0009, GeneratedExtensions.VolumeArchetypeExtensionTest0009.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0010))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0010, GeneratedExtensions.VolumeArchetypeExtensionTest0010.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0011))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0011, GeneratedExtensions.VolumeArchetypeExtensionTest0011.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0012))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0012, GeneratedExtensions.VolumeArchetypeExtensionTest0012.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0013))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0013, GeneratedExtensions.VolumeArchetypeExtensionTest0013.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0014))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0014, GeneratedExtensions.VolumeArchetypeExtensionTest0014.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0015))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0015, GeneratedExtensions.VolumeArchetypeExtensionTest0015.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0016))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0016, GeneratedExtensions.VolumeArchetypeExtensionTest0016.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0017))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0017, GeneratedExtensions.VolumeArchetypeExtensionTest0017.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0018))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0018, GeneratedExtensions.VolumeArchetypeExtensionTest0018.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0019))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0019, GeneratedExtensions.VolumeArchetypeExtensionTest0019.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0020))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0020, GeneratedExtensions.VolumeArchetypeExtensionTest0020.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0021))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0021, GeneratedExtensions.VolumeArchetypeExtensionTest0021.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0022))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0022, GeneratedExtensions.VolumeArchetypeExtensionTest0022.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0023))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0023, GeneratedExtensions.VolumeArchetypeExtensionTest0023.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0024))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0024, GeneratedExtensions.VolumeArchetypeExtensionTest0024.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0025))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0025, GeneratedExtensions.VolumeArchetypeExtensionTest0025.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0026))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0026, GeneratedExtensions.VolumeArchetypeExtensionTest0026.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0027))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0027, GeneratedExtensions.VolumeArchetypeExtensionTest0027.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0028))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0028, GeneratedExtensions.VolumeArchetypeExtensionTest0028.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0029))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0029, GeneratedExtensions.VolumeArchetypeExtensionTest0029.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0030))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0030, GeneratedExtensions.VolumeArchetypeExtensionTest0030.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0031))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0031, GeneratedExtensions.VolumeArchetypeExtensionTest0031.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0032))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0032, GeneratedExtensions.VolumeArchetypeExtensionTest0032.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0033))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0033, GeneratedExtensions.VolumeArchetypeExtensionTest0033.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0034))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0034, GeneratedExtensions.VolumeArchetypeExtensionTest0034.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0035))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0035, GeneratedExtensions.VolumeArchetypeExtensionTest0035.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0036))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0036, GeneratedExtensions.VolumeArchetypeExtensionTest0036.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0037))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0037, GeneratedExtensions.VolumeArchetypeExtensionTest0037.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0038))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0038, GeneratedExtensions.VolumeArchetypeExtensionTest0038.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0039))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0039, GeneratedExtensions.VolumeArchetypeExtensionTest0039.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0040))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0040, GeneratedExtensions.VolumeArchetypeExtensionTest0040.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0041))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0041, GeneratedExtensions.VolumeArchetypeExtensionTest0041.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0042))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0042, GeneratedExtensions.VolumeArchetypeExtensionTest0042.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0043))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0043, GeneratedExtensions.VolumeArchetypeExtensionTest0043.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0044))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0044, GeneratedExtensions.VolumeArchetypeExtensionTest0044.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0045))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0045, GeneratedExtensions.VolumeArchetypeExtensionTest0045.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0046))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0046, GeneratedExtensions.VolumeArchetypeExtensionTest0046.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0047))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0047, GeneratedExtensions.VolumeArchetypeExtensionTest0047.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0048))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0048, GeneratedExtensions.VolumeArchetypeExtensionTest0048.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0049))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0049, GeneratedExtensions.VolumeArchetypeExtensionTest0049.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0050))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0050, GeneratedExtensions.VolumeArchetypeExtensionTest0050.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0051))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0051, GeneratedExtensions.VolumeArchetypeExtensionTest0051.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0052))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0052, GeneratedExtensions.VolumeArchetypeExtensionTest0052.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0053))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0053, GeneratedExtensions.VolumeArchetypeExtensionTest0053.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0054))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0054, GeneratedExtensions.VolumeArchetypeExtensionTest0054.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0055))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0055, GeneratedExtensions.VolumeArchetypeExtensionTest0055.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0056))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0056, GeneratedExtensions.VolumeArchetypeExtensionTest0056.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0057))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0057, GeneratedExtensions.VolumeArchetypeExtensionTest0057.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0058))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0058, GeneratedExtensions.VolumeArchetypeExtensionTest0058.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0059))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0059, GeneratedExtensions.VolumeArchetypeExtensionTest0059.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0060))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0060, GeneratedExtensions.VolumeArchetypeExtensionTest0060.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0061))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0061, GeneratedExtensions.VolumeArchetypeExtensionTest0061.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0062))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0062, GeneratedExtensions.VolumeArchetypeExtensionTest0062.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0063))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0063, GeneratedExtensions.VolumeArchetypeExtensionTest0063.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0064))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0064, GeneratedExtensions.VolumeArchetypeExtensionTest0064.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0065))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0065, GeneratedExtensions.VolumeArchetypeExtensionTest0065.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0066))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0066, GeneratedExtensions.VolumeArchetypeExtensionTest0066.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0067))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0067, GeneratedExtensions.VolumeArchetypeExtensionTest0067.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0068))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0068, GeneratedExtensions.VolumeArchetypeExtensionTest0068.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0069))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0069, GeneratedExtensions.VolumeArchetypeExtensionTest0069.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0070))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0070, GeneratedExtensions.VolumeArchetypeExtensionTest0070.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0071))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0071, GeneratedExtensions.VolumeArchetypeExtensionTest0071.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0072))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0072, GeneratedExtensions.VolumeArchetypeExtensionTest0072.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0073))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0073, GeneratedExtensions.VolumeArchetypeExtensionTest0073.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0074))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0074, GeneratedExtensions.VolumeArchetypeExtensionTest0074.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0075))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0075, GeneratedExtensions.VolumeArchetypeExtensionTest0075.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0076))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0076, GeneratedExtensions.VolumeArchetypeExtensionTest0076.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0077))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0077, GeneratedExtensions.VolumeArchetypeExtensionTest0077.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0078))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0078, GeneratedExtensions.VolumeArchetypeExtensionTest0078.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0079))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0079, GeneratedExtensions.VolumeArchetypeExtensionTest0079.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0080))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0080, GeneratedExtensions.VolumeArchetypeExtensionTest0080.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0081))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0081, GeneratedExtensions.VolumeArchetypeExtensionTest0081.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0082))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0082, GeneratedExtensions.VolumeArchetypeExtensionTest0082.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0083))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0083, GeneratedExtensions.VolumeArchetypeExtensionTest0083.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0084))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0084, GeneratedExtensions.VolumeArchetypeExtensionTest0084.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0085))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0085, GeneratedExtensions.VolumeArchetypeExtensionTest0085.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0086))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0086, GeneratedExtensions.VolumeArchetypeExtensionTest0086.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0087))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0087, GeneratedExtensions.VolumeArchetypeExtensionTest0087.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0088))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0088, GeneratedExtensions.VolumeArchetypeExtensionTest0088.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0089))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0089, GeneratedExtensions.VolumeArchetypeExtensionTest0089.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0090))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0090, GeneratedExtensions.VolumeArchetypeExtensionTest0090.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0091))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0091, GeneratedExtensions.VolumeArchetypeExtensionTest0091.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0092))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0092, GeneratedExtensions.VolumeArchetypeExtensionTest0092.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0093))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0093, GeneratedExtensions.VolumeArchetypeExtensionTest0093.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0094))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0094, GeneratedExtensions.VolumeArchetypeExtensionTest0094.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0095))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0095, GeneratedExtensions.VolumeArchetypeExtensionTest0095.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0096))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0096, GeneratedExtensions.VolumeArchetypeExtensionTest0096.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0097))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0097, GeneratedExtensions.VolumeArchetypeExtensionTest0097.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0098))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0098, GeneratedExtensions.VolumeArchetypeExtensionTest0098.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0099))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0099, GeneratedExtensions.VolumeArchetypeExtensionTest0099.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0100))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0100, GeneratedExtensions.VolumeArchetypeExtensionTest0100.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0101))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0101, GeneratedExtensions.VolumeArchetypeExtensionTest0101.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0102))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0102, GeneratedExtensions.VolumeArchetypeExtensionTest0102.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0103))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0103, GeneratedExtensions.VolumeArchetypeExtensionTest0103.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0104))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0104, GeneratedExtensions.VolumeArchetypeExtensionTest0104.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0105))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0105, GeneratedExtensions.VolumeArchetypeExtensionTest0105.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0106))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0106, GeneratedExtensions.VolumeArchetypeExtensionTest0106.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0107))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0107, GeneratedExtensions.VolumeArchetypeExtensionTest0107.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0108))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0108, GeneratedExtensions.VolumeArchetypeExtensionTest0108.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0109))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0109, GeneratedExtensions.VolumeArchetypeExtensionTest0109.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0110))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0110, GeneratedExtensions.VolumeArchetypeExtensionTest0110.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0111))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0111, GeneratedExtensions.VolumeArchetypeExtensionTest0111.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0112))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0112, GeneratedExtensions.VolumeArchetypeExtensionTest0112.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0113))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0113, GeneratedExtensions.VolumeArchetypeExtensionTest0113.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0114))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0114, GeneratedExtensions.VolumeArchetypeExtensionTest0114.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0115))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0115, GeneratedExtensions.VolumeArchetypeExtensionTest0115.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0116))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0116, GeneratedExtensions.VolumeArchetypeExtensionTest0116.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0117))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0117, GeneratedExtensions.VolumeArchetypeExtensionTest0117.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0118))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0118, GeneratedExtensions.VolumeArchetypeExtensionTest0118.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0119))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0119, GeneratedExtensions.VolumeArchetypeExtensionTest0119.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0120))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0120, GeneratedExtensions.VolumeArchetypeExtensionTest0120.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0121))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0121, GeneratedExtensions.VolumeArchetypeExtensionTest0121.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0122))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0122, GeneratedExtensions.VolumeArchetypeExtensionTest0122.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0123))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0123, GeneratedExtensions.VolumeArchetypeExtensionTest0123.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0124))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0124, GeneratedExtensions.VolumeArchetypeExtensionTest0124.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0125))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0125, GeneratedExtensions.VolumeArchetypeExtensionTest0125.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0126))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0126, GeneratedExtensions.VolumeArchetypeExtensionTest0126.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0127))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0127, GeneratedExtensions.VolumeArchetypeExtensionTest0127.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0128))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0128, GeneratedExtensions.VolumeArchetypeExtensionTest0128.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0129))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0129, GeneratedExtensions.VolumeArchetypeExtensionTest0129.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0130))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0130, GeneratedExtensions.VolumeArchetypeExtensionTest0130.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0131))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0131, GeneratedExtensions.VolumeArchetypeExtensionTest0131.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0132))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0132, GeneratedExtensions.VolumeArchetypeExtensionTest0132.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0133))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0133, GeneratedExtensions.VolumeArchetypeExtensionTest0133.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0134))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0134, GeneratedExtensions.VolumeArchetypeExtensionTest0134.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0135))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0135, GeneratedExtensions.VolumeArchetypeExtensionTest0135.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0136))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0136, GeneratedExtensions.VolumeArchetypeExtensionTest0136.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0137))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0137, GeneratedExtensions.VolumeArchetypeExtensionTest0137.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0138))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0138, GeneratedExtensions.VolumeArchetypeExtensionTest0138.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0139))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0139, GeneratedExtensions.VolumeArchetypeExtensionTest0139.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0140))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0140, GeneratedExtensions.VolumeArchetypeExtensionTest0140.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0141))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0141, GeneratedExtensions.VolumeArchetypeExtensionTest0141.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0142))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0142, GeneratedExtensions.VolumeArchetypeExtensionTest0142.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0143))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0143, GeneratedExtensions.VolumeArchetypeExtensionTest0143.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0144))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0144, GeneratedExtensions.VolumeArchetypeExtensionTest0144.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0145))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0145, GeneratedExtensions.VolumeArchetypeExtensionTest0145.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0146))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0146, GeneratedExtensions.VolumeArchetypeExtensionTest0146.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0147))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0147, GeneratedExtensions.VolumeArchetypeExtensionTest0147.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0148))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0148, GeneratedExtensions.VolumeArchetypeExtensionTest0148.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0149))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0149, GeneratedExtensions.VolumeArchetypeExtensionTest0149.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0150))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0150, GeneratedExtensions.VolumeArchetypeExtensionTest0150.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0151))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0151, GeneratedExtensions.VolumeArchetypeExtensionTest0151.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0152))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0152, GeneratedExtensions.VolumeArchetypeExtensionTest0152.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0153))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0153, GeneratedExtensions.VolumeArchetypeExtensionTest0153.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0154))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0154, GeneratedExtensions.VolumeArchetypeExtensionTest0154.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0155))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0155, GeneratedExtensions.VolumeArchetypeExtensionTest0155.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0156))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0156, GeneratedExtensions.VolumeArchetypeExtensionTest0156.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0157))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0157, GeneratedExtensions.VolumeArchetypeExtensionTest0157.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0158))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0158, GeneratedExtensions.VolumeArchetypeExtensionTest0158.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0159))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0159, GeneratedExtensions.VolumeArchetypeExtensionTest0159.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0160))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0160, GeneratedExtensions.VolumeArchetypeExtensionTest0160.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0161))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0161, GeneratedExtensions.VolumeArchetypeExtensionTest0161.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0162))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0162, GeneratedExtensions.VolumeArchetypeExtensionTest0162.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0163))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0163, GeneratedExtensions.VolumeArchetypeExtensionTest0163.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0164))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0164, GeneratedExtensions.VolumeArchetypeExtensionTest0164.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0165))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0165, GeneratedExtensions.VolumeArchetypeExtensionTest0165.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0166))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0166, GeneratedExtensions.VolumeArchetypeExtensionTest0166.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0167))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0167, GeneratedExtensions.VolumeArchetypeExtensionTest0167.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0168))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0168, GeneratedExtensions.VolumeArchetypeExtensionTest0168.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0169))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0169, GeneratedExtensions.VolumeArchetypeExtensionTest0169.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0170))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0170, GeneratedExtensions.VolumeArchetypeExtensionTest0170.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0171))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0171, GeneratedExtensions.VolumeArchetypeExtensionTest0171.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0172))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0172, GeneratedExtensions.VolumeArchetypeExtensionTest0172.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0173))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0173, GeneratedExtensions.VolumeArchetypeExtensionTest0173.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0174))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0174, GeneratedExtensions.VolumeArchetypeExtensionTest0174.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0175))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0175, GeneratedExtensions.VolumeArchetypeExtensionTest0175.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0176))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0176, GeneratedExtensions.VolumeArchetypeExtensionTest0176.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0177))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0177, GeneratedExtensions.VolumeArchetypeExtensionTest0177.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0178))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0178, GeneratedExtensions.VolumeArchetypeExtensionTest0178.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0179))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0179, GeneratedExtensions.VolumeArchetypeExtensionTest0179.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0180))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0180, GeneratedExtensions.VolumeArchetypeExtensionTest0180.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0181))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0181, GeneratedExtensions.VolumeArchetypeExtensionTest0181.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0182))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0182, GeneratedExtensions.VolumeArchetypeExtensionTest0182.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0183))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0183, GeneratedExtensions.VolumeArchetypeExtensionTest0183.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0184))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0184, GeneratedExtensions.VolumeArchetypeExtensionTest0184.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0185))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0185, GeneratedExtensions.VolumeArchetypeExtensionTest0185.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0186))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0186, GeneratedExtensions.VolumeArchetypeExtensionTest0186.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0187))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0187, GeneratedExtensions.VolumeArchetypeExtensionTest0187.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0188))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0188, GeneratedExtensions.VolumeArchetypeExtensionTest0188.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0189))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0189, GeneratedExtensions.VolumeArchetypeExtensionTest0189.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0190))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0190, GeneratedExtensions.VolumeArchetypeExtensionTest0190.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0191))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0191, GeneratedExtensions.VolumeArchetypeExtensionTest0191.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0192))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0192, GeneratedExtensions.VolumeArchetypeExtensionTest0192.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0193))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0193, GeneratedExtensions.VolumeArchetypeExtensionTest0193.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0194))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0194, GeneratedExtensions.VolumeArchetypeExtensionTest0194.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0195))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0195, GeneratedExtensions.VolumeArchetypeExtensionTest0195.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0196))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0196, GeneratedExtensions.VolumeArchetypeExtensionTest0196.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0197))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0197, GeneratedExtensions.VolumeArchetypeExtensionTest0197.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0198))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0198, GeneratedExtensions.VolumeArchetypeExtensionTest0198.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0199))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0199, GeneratedExtensions.VolumeArchetypeExtensionTest0199.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0200))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0200, GeneratedExtensions.VolumeArchetypeExtensionTest0200.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0201))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0201, GeneratedExtensions.VolumeArchetypeExtensionTest0201.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0202))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0202, GeneratedExtensions.VolumeArchetypeExtensionTest0202.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0203))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0203, GeneratedExtensions.VolumeArchetypeExtensionTest0203.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0204))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0204, GeneratedExtensions.VolumeArchetypeExtensionTest0204.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0205))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0205, GeneratedExtensions.VolumeArchetypeExtensionTest0205.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0206))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0206, GeneratedExtensions.VolumeArchetypeExtensionTest0206.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0207))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0207, GeneratedExtensions.VolumeArchetypeExtensionTest0207.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0208))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0208, GeneratedExtensions.VolumeArchetypeExtensionTest0208.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0209))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0209, GeneratedExtensions.VolumeArchetypeExtensionTest0209.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0210))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0210, GeneratedExtensions.VolumeArchetypeExtensionTest0210.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0211))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0211, GeneratedExtensions.VolumeArchetypeExtensionTest0211.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0212))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0212, GeneratedExtensions.VolumeArchetypeExtensionTest0212.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0213))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0213, GeneratedExtensions.VolumeArchetypeExtensionTest0213.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0214))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0214, GeneratedExtensions.VolumeArchetypeExtensionTest0214.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0215))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0215, GeneratedExtensions.VolumeArchetypeExtensionTest0215.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0216))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0216, GeneratedExtensions.VolumeArchetypeExtensionTest0216.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0217))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0217, GeneratedExtensions.VolumeArchetypeExtensionTest0217.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0218))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0218, GeneratedExtensions.VolumeArchetypeExtensionTest0218.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0219))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0219, GeneratedExtensions.VolumeArchetypeExtensionTest0219.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0220))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0220, GeneratedExtensions.VolumeArchetypeExtensionTest0220.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0221))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0221, GeneratedExtensions.VolumeArchetypeExtensionTest0221.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0222))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0222, GeneratedExtensions.VolumeArchetypeExtensionTest0222.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0223))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0223, GeneratedExtensions.VolumeArchetypeExtensionTest0223.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0224))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0224, GeneratedExtensions.VolumeArchetypeExtensionTest0224.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0225))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0225, GeneratedExtensions.VolumeArchetypeExtensionTest0225.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0226))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0226, GeneratedExtensions.VolumeArchetypeExtensionTest0226.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0227))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0227, GeneratedExtensions.VolumeArchetypeExtensionTest0227.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0228))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0228, GeneratedExtensions.VolumeArchetypeExtensionTest0228.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0229))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0229, GeneratedExtensions.VolumeArchetypeExtensionTest0229.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0230))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0230, GeneratedExtensions.VolumeArchetypeExtensionTest0230.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0231))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0231, GeneratedExtensions.VolumeArchetypeExtensionTest0231.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0232))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0232, GeneratedExtensions.VolumeArchetypeExtensionTest0232.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0233))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0233, GeneratedExtensions.VolumeArchetypeExtensionTest0233.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0234))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0234, GeneratedExtensions.VolumeArchetypeExtensionTest0234.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0235))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0235, GeneratedExtensions.VolumeArchetypeExtensionTest0235.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0236))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0236, GeneratedExtensions.VolumeArchetypeExtensionTest0236.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0237))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0237, GeneratedExtensions.VolumeArchetypeExtensionTest0237.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0238))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0238, GeneratedExtensions.VolumeArchetypeExtensionTest0238.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0239))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0239, GeneratedExtensions.VolumeArchetypeExtensionTest0239.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0240))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0240, GeneratedExtensions.VolumeArchetypeExtensionTest0240.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0241))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0241, GeneratedExtensions.VolumeArchetypeExtensionTest0241.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0242))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0242, GeneratedExtensions.VolumeArchetypeExtensionTest0242.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0243))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0243, GeneratedExtensions.VolumeArchetypeExtensionTest0243.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0244))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0244, GeneratedExtensions.VolumeArchetypeExtensionTest0244.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0245))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0245, GeneratedExtensions.VolumeArchetypeExtensionTest0245.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0246))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0246, GeneratedExtensions.VolumeArchetypeExtensionTest0246.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0247))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0247, GeneratedExtensions.VolumeArchetypeExtensionTest0247.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0248))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0248, GeneratedExtensions.VolumeArchetypeExtensionTest0248.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0249))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0249, GeneratedExtensions.VolumeArchetypeExtensionTest0249.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0250))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0250, GeneratedExtensions.VolumeArchetypeExtensionTest0250.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0251))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0251, GeneratedExtensions.VolumeArchetypeExtensionTest0251.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0252))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0252, GeneratedExtensions.VolumeArchetypeExtensionTest0252.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0253))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0253, GeneratedExtensions.VolumeArchetypeExtensionTest0253.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0254))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0254, GeneratedExtensions.VolumeArchetypeExtensionTest0254.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0255))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0255, GeneratedExtensions.VolumeArchetypeExtensionTest0255.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0256))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0256, GeneratedExtensions.VolumeArchetypeExtensionTest0256.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0257))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0257, GeneratedExtensions.VolumeArchetypeExtensionTest0257.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0258))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0258, GeneratedExtensions.VolumeArchetypeExtensionTest0258.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0259))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0259, GeneratedExtensions.VolumeArchetypeExtensionTest0259.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0260))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0260, GeneratedExtensions.VolumeArchetypeExtensionTest0260.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0261))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0261, GeneratedExtensions.VolumeArchetypeExtensionTest0261.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0262))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0262, GeneratedExtensions.VolumeArchetypeExtensionTest0262.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0263))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0263, GeneratedExtensions.VolumeArchetypeExtensionTest0263.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0264))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0264, GeneratedExtensions.VolumeArchetypeExtensionTest0264.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0265))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0265, GeneratedExtensions.VolumeArchetypeExtensionTest0265.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0266))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0266, GeneratedExtensions.VolumeArchetypeExtensionTest0266.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0267))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0267, GeneratedExtensions.VolumeArchetypeExtensionTest0267.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0268))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0268, GeneratedExtensions.VolumeArchetypeExtensionTest0268.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0269))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0269, GeneratedExtensions.VolumeArchetypeExtensionTest0269.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0270))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0270, GeneratedExtensions.VolumeArchetypeExtensionTest0270.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0271))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0271, GeneratedExtensions.VolumeArchetypeExtensionTest0271.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0272))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0272, GeneratedExtensions.VolumeArchetypeExtensionTest0272.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0273))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0273, GeneratedExtensions.VolumeArchetypeExtensionTest0273.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0274))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0274, GeneratedExtensions.VolumeArchetypeExtensionTest0274.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0275))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0275, GeneratedExtensions.VolumeArchetypeExtensionTest0275.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0276))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0276, GeneratedExtensions.VolumeArchetypeExtensionTest0276.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0277))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0277, GeneratedExtensions.VolumeArchetypeExtensionTest0277.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0278))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0278, GeneratedExtensions.VolumeArchetypeExtensionTest0278.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0279))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0279, GeneratedExtensions.VolumeArchetypeExtensionTest0279.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0280))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0280, GeneratedExtensions.VolumeArchetypeExtensionTest0280.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0281))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0281, GeneratedExtensions.VolumeArchetypeExtensionTest0281.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0282))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0282, GeneratedExtensions.VolumeArchetypeExtensionTest0282.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0283))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0283, GeneratedExtensions.VolumeArchetypeExtensionTest0283.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0284))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0284, GeneratedExtensions.VolumeArchetypeExtensionTest0284.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0285))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0285, GeneratedExtensions.VolumeArchetypeExtensionTest0285.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0286))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0286, GeneratedExtensions.VolumeArchetypeExtensionTest0286.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0287))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0287, GeneratedExtensions.VolumeArchetypeExtensionTest0287.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0288))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0288, GeneratedExtensions.VolumeArchetypeExtensionTest0288.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0289))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0289, GeneratedExtensions.VolumeArchetypeExtensionTest0289.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0290))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0290, GeneratedExtensions.VolumeArchetypeExtensionTest0290.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0291))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0291, GeneratedExtensions.VolumeArchetypeExtensionTest0291.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0292))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0292, GeneratedExtensions.VolumeArchetypeExtensionTest0292.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0293))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0293, GeneratedExtensions.VolumeArchetypeExtensionTest0293.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0294))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0294, GeneratedExtensions.VolumeArchetypeExtensionTest0294.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0295))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0295, GeneratedExtensions.VolumeArchetypeExtensionTest0295.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0296))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0296, GeneratedExtensions.VolumeArchetypeExtensionTest0296.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0297))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0297, GeneratedExtensions.VolumeArchetypeExtensionTest0297.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0298))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0298, GeneratedExtensions.VolumeArchetypeExtensionTest0298.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0299))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0299, GeneratedExtensions.VolumeArchetypeExtensionTest0299.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0300))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0300, GeneratedExtensions.VolumeArchetypeExtensionTest0300.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0301))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0301, GeneratedExtensions.VolumeArchetypeExtensionTest0301.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0302))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0302, GeneratedExtensions.VolumeArchetypeExtensionTest0302.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0303))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0303, GeneratedExtensions.VolumeArchetypeExtensionTest0303.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0304))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0304, GeneratedExtensions.VolumeArchetypeExtensionTest0304.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0305))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0305, GeneratedExtensions.VolumeArchetypeExtensionTest0305.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0306))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0306, GeneratedExtensions.VolumeArchetypeExtensionTest0306.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0307))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0307, GeneratedExtensions.VolumeArchetypeExtensionTest0307.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0308))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0308, GeneratedExtensions.VolumeArchetypeExtensionTest0308.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0309))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0309, GeneratedExtensions.VolumeArchetypeExtensionTest0309.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0310))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0310, GeneratedExtensions.VolumeArchetypeExtensionTest0310.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0311))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0311, GeneratedExtensions.VolumeArchetypeExtensionTest0311.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0312))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0312, GeneratedExtensions.VolumeArchetypeExtensionTest0312.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0313))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0313, GeneratedExtensions.VolumeArchetypeExtensionTest0313.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0314))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0314, GeneratedExtensions.VolumeArchetypeExtensionTest0314.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0315))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0315, GeneratedExtensions.VolumeArchetypeExtensionTest0315.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0316))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0316, GeneratedExtensions.VolumeArchetypeExtensionTest0316.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0317))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0317, GeneratedExtensions.VolumeArchetypeExtensionTest0317.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0318))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0318, GeneratedExtensions.VolumeArchetypeExtensionTest0318.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0319))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0319, GeneratedExtensions.VolumeArchetypeExtensionTest0319.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0320))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0320, GeneratedExtensions.VolumeArchetypeExtensionTest0320.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0321))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0321, GeneratedExtensions.VolumeArchetypeExtensionTest0321.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0322))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0322, GeneratedExtensions.VolumeArchetypeExtensionTest0322.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0323))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0323, GeneratedExtensions.VolumeArchetypeExtensionTest0323.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0324))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0324, GeneratedExtensions.VolumeArchetypeExtensionTest0324.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0325))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0325, GeneratedExtensions.VolumeArchetypeExtensionTest0325.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0326))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0326, GeneratedExtensions.VolumeArchetypeExtensionTest0326.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0327))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0327, GeneratedExtensions.VolumeArchetypeExtensionTest0327.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0328))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0328, GeneratedExtensions.VolumeArchetypeExtensionTest0328.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0329))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0329, GeneratedExtensions.VolumeArchetypeExtensionTest0329.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0330))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0330, GeneratedExtensions.VolumeArchetypeExtensionTest0330.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0331))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0331, GeneratedExtensions.VolumeArchetypeExtensionTest0331.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0332))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0332, GeneratedExtensions.VolumeArchetypeExtensionTest0332.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0333))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0333, GeneratedExtensions.VolumeArchetypeExtensionTest0333.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0334))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0334, GeneratedExtensions.VolumeArchetypeExtensionTest0334.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0335))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0335, GeneratedExtensions.VolumeArchetypeExtensionTest0335.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0336))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0336, GeneratedExtensions.VolumeArchetypeExtensionTest0336.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0337))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0337, GeneratedExtensions.VolumeArchetypeExtensionTest0337.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0338))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0338, GeneratedExtensions.VolumeArchetypeExtensionTest0338.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0339))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0339, GeneratedExtensions.VolumeArchetypeExtensionTest0339.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0340))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0340, GeneratedExtensions.VolumeArchetypeExtensionTest0340.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0341))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0341, GeneratedExtensions.VolumeArchetypeExtensionTest0341.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0342))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0342, GeneratedExtensions.VolumeArchetypeExtensionTest0342.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0343))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0343, GeneratedExtensions.VolumeArchetypeExtensionTest0343.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0344))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0344, GeneratedExtensions.VolumeArchetypeExtensionTest0344.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0345))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0345, GeneratedExtensions.VolumeArchetypeExtensionTest0345.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0346))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0346, GeneratedExtensions.VolumeArchetypeExtensionTest0346.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0347))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0347, GeneratedExtensions.VolumeArchetypeExtensionTest0347.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0348))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0348, GeneratedExtensions.VolumeArchetypeExtensionTest0348.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0349))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0349, GeneratedExtensions.VolumeArchetypeExtensionTest0349.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0350))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0350, GeneratedExtensions.VolumeArchetypeExtensionTest0350.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0351))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0351, GeneratedExtensions.VolumeArchetypeExtensionTest0351.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0352))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0352, GeneratedExtensions.VolumeArchetypeExtensionTest0352.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0353))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0353, GeneratedExtensions.VolumeArchetypeExtensionTest0353.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0354))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0354, GeneratedExtensions.VolumeArchetypeExtensionTest0354.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0355))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0355, GeneratedExtensions.VolumeArchetypeExtensionTest0355.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0356))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0356, GeneratedExtensions.VolumeArchetypeExtensionTest0356.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0357))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0357, GeneratedExtensions.VolumeArchetypeExtensionTest0357.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0358))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0358, GeneratedExtensions.VolumeArchetypeExtensionTest0358.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0359))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0359, GeneratedExtensions.VolumeArchetypeExtensionTest0359.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0360))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0360, GeneratedExtensions.VolumeArchetypeExtensionTest0360.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0361))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0361, GeneratedExtensions.VolumeArchetypeExtensionTest0361.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0362))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0362, GeneratedExtensions.VolumeArchetypeExtensionTest0362.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0363))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0363, GeneratedExtensions.VolumeArchetypeExtensionTest0363.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0364))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0364, GeneratedExtensions.VolumeArchetypeExtensionTest0364.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0365))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0365, GeneratedExtensions.VolumeArchetypeExtensionTest0365.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0366))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0366, GeneratedExtensions.VolumeArchetypeExtensionTest0366.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0367))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0367, GeneratedExtensions.VolumeArchetypeExtensionTest0367.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0368))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0368, GeneratedExtensions.VolumeArchetypeExtensionTest0368.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0369))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0369, GeneratedExtensions.VolumeArchetypeExtensionTest0369.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0370))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0370, GeneratedExtensions.VolumeArchetypeExtensionTest0370.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0371))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0371, GeneratedExtensions.VolumeArchetypeExtensionTest0371.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0372))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0372, GeneratedExtensions.VolumeArchetypeExtensionTest0372.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0373))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0373, GeneratedExtensions.VolumeArchetypeExtensionTest0373.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0374))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0374, GeneratedExtensions.VolumeArchetypeExtensionTest0374.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0375))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0375, GeneratedExtensions.VolumeArchetypeExtensionTest0375.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0376))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0376, GeneratedExtensions.VolumeArchetypeExtensionTest0376.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0377))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0377, GeneratedExtensions.VolumeArchetypeExtensionTest0377.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0378))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0378, GeneratedExtensions.VolumeArchetypeExtensionTest0378.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0379))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0379, GeneratedExtensions.VolumeArchetypeExtensionTest0379.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0380))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0380, GeneratedExtensions.VolumeArchetypeExtensionTest0380.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0381))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0381, GeneratedExtensions.VolumeArchetypeExtensionTest0381.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0382))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0382, GeneratedExtensions.VolumeArchetypeExtensionTest0382.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0383))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0383, GeneratedExtensions.VolumeArchetypeExtensionTest0383.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0384))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0384, GeneratedExtensions.VolumeArchetypeExtensionTest0384.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0385))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0385, GeneratedExtensions.VolumeArchetypeExtensionTest0385.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0386))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0386, GeneratedExtensions.VolumeArchetypeExtensionTest0386.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0387))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0387, GeneratedExtensions.VolumeArchetypeExtensionTest0387.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0388))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0388, GeneratedExtensions.VolumeArchetypeExtensionTest0388.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0389))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0389, GeneratedExtensions.VolumeArchetypeExtensionTest0389.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0390))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0390, GeneratedExtensions.VolumeArchetypeExtensionTest0390.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0391))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0391, GeneratedExtensions.VolumeArchetypeExtensionTest0391.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0392))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0392, GeneratedExtensions.VolumeArchetypeExtensionTest0392.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0393))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0393, GeneratedExtensions.VolumeArchetypeExtensionTest0393.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0394))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0394, GeneratedExtensions.VolumeArchetypeExtensionTest0394.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0395))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0395, GeneratedExtensions.VolumeArchetypeExtensionTest0395.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0396))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0396, GeneratedExtensions.VolumeArchetypeExtensionTest0396.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0397))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0397, GeneratedExtensions.VolumeArchetypeExtensionTest0397.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0398))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0398, GeneratedExtensions.VolumeArchetypeExtensionTest0398.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0399))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0399, GeneratedExtensions.VolumeArchetypeExtensionTest0399.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0400))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0400, GeneratedExtensions.VolumeArchetypeExtensionTest0400.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0401))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0401, GeneratedExtensions.VolumeArchetypeExtensionTest0401.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0402))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0402, GeneratedExtensions.VolumeArchetypeExtensionTest0402.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0403))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0403, GeneratedExtensions.VolumeArchetypeExtensionTest0403.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0404))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0404, GeneratedExtensions.VolumeArchetypeExtensionTest0404.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0405))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0405, GeneratedExtensions.VolumeArchetypeExtensionTest0405.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0406))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0406, GeneratedExtensions.VolumeArchetypeExtensionTest0406.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0407))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0407, GeneratedExtensions.VolumeArchetypeExtensionTest0407.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0408))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0408, GeneratedExtensions.VolumeArchetypeExtensionTest0408.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0409))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0409, GeneratedExtensions.VolumeArchetypeExtensionTest0409.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0410))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0410, GeneratedExtensions.VolumeArchetypeExtensionTest0410.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0411))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0411, GeneratedExtensions.VolumeArchetypeExtensionTest0411.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0412))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0412, GeneratedExtensions.VolumeArchetypeExtensionTest0412.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0413))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0413, GeneratedExtensions.VolumeArchetypeExtensionTest0413.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0414))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0414, GeneratedExtensions.VolumeArchetypeExtensionTest0414.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0415))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0415, GeneratedExtensions.VolumeArchetypeExtensionTest0415.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0416))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0416, GeneratedExtensions.VolumeArchetypeExtensionTest0416.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0417))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0417, GeneratedExtensions.VolumeArchetypeExtensionTest0417.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0418))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0418, GeneratedExtensions.VolumeArchetypeExtensionTest0418.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0419))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0419, GeneratedExtensions.VolumeArchetypeExtensionTest0419.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0420))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0420, GeneratedExtensions.VolumeArchetypeExtensionTest0420.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0421))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0421, GeneratedExtensions.VolumeArchetypeExtensionTest0421.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0422))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0422, GeneratedExtensions.VolumeArchetypeExtensionTest0422.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0423))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0423, GeneratedExtensions.VolumeArchetypeExtensionTest0423.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0424))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0424, GeneratedExtensions.VolumeArchetypeExtensionTest0424.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0425))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0425, GeneratedExtensions.VolumeArchetypeExtensionTest0425.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0426))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0426, GeneratedExtensions.VolumeArchetypeExtensionTest0426.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0427))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0427, GeneratedExtensions.VolumeArchetypeExtensionTest0427.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0428))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0428, GeneratedExtensions.VolumeArchetypeExtensionTest0428.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0429))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0429, GeneratedExtensions.VolumeArchetypeExtensionTest0429.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0430))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0430, GeneratedExtensions.VolumeArchetypeExtensionTest0430.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0431))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0431, GeneratedExtensions.VolumeArchetypeExtensionTest0431.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0432))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0432, GeneratedExtensions.VolumeArchetypeExtensionTest0432.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0433))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0433, GeneratedExtensions.VolumeArchetypeExtensionTest0433.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0434))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0434, GeneratedExtensions.VolumeArchetypeExtensionTest0434.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0435))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0435, GeneratedExtensions.VolumeArchetypeExtensionTest0435.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0436))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0436, GeneratedExtensions.VolumeArchetypeExtensionTest0436.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0437))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0437, GeneratedExtensions.VolumeArchetypeExtensionTest0437.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0438))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0438, GeneratedExtensions.VolumeArchetypeExtensionTest0438.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0439))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0439, GeneratedExtensions.VolumeArchetypeExtensionTest0439.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0440))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0440, GeneratedExtensions.VolumeArchetypeExtensionTest0440.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0441))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0441, GeneratedExtensions.VolumeArchetypeExtensionTest0441.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0442))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0442, GeneratedExtensions.VolumeArchetypeExtensionTest0442.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0443))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0443, GeneratedExtensions.VolumeArchetypeExtensionTest0443.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0444))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0444, GeneratedExtensions.VolumeArchetypeExtensionTest0444.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0445))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0445, GeneratedExtensions.VolumeArchetypeExtensionTest0445.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0446))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0446, GeneratedExtensions.VolumeArchetypeExtensionTest0446.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0447))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0447, GeneratedExtensions.VolumeArchetypeExtensionTest0447.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0448))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0448, GeneratedExtensions.VolumeArchetypeExtensionTest0448.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0449))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0449, GeneratedExtensions.VolumeArchetypeExtensionTest0449.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0450))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0450, GeneratedExtensions.VolumeArchetypeExtensionTest0450.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0451))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0451, GeneratedExtensions.VolumeArchetypeExtensionTest0451.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0452))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0452, GeneratedExtensions.VolumeArchetypeExtensionTest0452.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0453))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0453, GeneratedExtensions.VolumeArchetypeExtensionTest0453.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0454))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0454, GeneratedExtensions.VolumeArchetypeExtensionTest0454.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0455))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0455, GeneratedExtensions.VolumeArchetypeExtensionTest0455.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0456))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0456, GeneratedExtensions.VolumeArchetypeExtensionTest0456.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0457))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0457, GeneratedExtensions.VolumeArchetypeExtensionTest0457.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0458))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0458, GeneratedExtensions.VolumeArchetypeExtensionTest0458.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0459))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0459, GeneratedExtensions.VolumeArchetypeExtensionTest0459.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0460))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0460, GeneratedExtensions.VolumeArchetypeExtensionTest0460.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0461))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0461, GeneratedExtensions.VolumeArchetypeExtensionTest0461.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0462))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0462, GeneratedExtensions.VolumeArchetypeExtensionTest0462.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0463))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0463, GeneratedExtensions.VolumeArchetypeExtensionTest0463.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0464))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0464, GeneratedExtensions.VolumeArchetypeExtensionTest0464.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0465))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0465, GeneratedExtensions.VolumeArchetypeExtensionTest0465.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0466))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0466, GeneratedExtensions.VolumeArchetypeExtensionTest0466.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0467))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0467, GeneratedExtensions.VolumeArchetypeExtensionTest0467.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0468))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0468, GeneratedExtensions.VolumeArchetypeExtensionTest0468.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0469))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0469, GeneratedExtensions.VolumeArchetypeExtensionTest0469.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0470))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0470, GeneratedExtensions.VolumeArchetypeExtensionTest0470.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0471))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0471, GeneratedExtensions.VolumeArchetypeExtensionTest0471.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0472))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0472, GeneratedExtensions.VolumeArchetypeExtensionTest0472.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0473))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0473, GeneratedExtensions.VolumeArchetypeExtensionTest0473.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0474))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0474, GeneratedExtensions.VolumeArchetypeExtensionTest0474.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0475))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0475, GeneratedExtensions.VolumeArchetypeExtensionTest0475.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0476))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0476, GeneratedExtensions.VolumeArchetypeExtensionTest0476.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0477))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0477, GeneratedExtensions.VolumeArchetypeExtensionTest0477.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0478))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0478, GeneratedExtensions.VolumeArchetypeExtensionTest0478.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0479))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0479, GeneratedExtensions.VolumeArchetypeExtensionTest0479.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0480))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0480, GeneratedExtensions.VolumeArchetypeExtensionTest0480.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0481))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0481, GeneratedExtensions.VolumeArchetypeExtensionTest0481.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0482))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0482, GeneratedExtensions.VolumeArchetypeExtensionTest0482.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0483))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0483, GeneratedExtensions.VolumeArchetypeExtensionTest0483.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0484))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0484, GeneratedExtensions.VolumeArchetypeExtensionTest0484.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0485))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0485, GeneratedExtensions.VolumeArchetypeExtensionTest0485.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0486))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0486, GeneratedExtensions.VolumeArchetypeExtensionTest0486.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0487))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0487, GeneratedExtensions.VolumeArchetypeExtensionTest0487.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0488))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0488, GeneratedExtensions.VolumeArchetypeExtensionTest0488.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0489))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0489, GeneratedExtensions.VolumeArchetypeExtensionTest0489.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0490))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0490, GeneratedExtensions.VolumeArchetypeExtensionTest0490.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0491))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0491, GeneratedExtensions.VolumeArchetypeExtensionTest0491.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0492))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0492, GeneratedExtensions.VolumeArchetypeExtensionTest0492.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0493))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0493, GeneratedExtensions.VolumeArchetypeExtensionTest0493.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0494))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0494, GeneratedExtensions.VolumeArchetypeExtensionTest0494.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0495))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0495, GeneratedExtensions.VolumeArchetypeExtensionTest0495.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0496))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0496, GeneratedExtensions.VolumeArchetypeExtensionTest0496.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0497))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0497, GeneratedExtensions.VolumeArchetypeExtensionTest0497.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0498))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0498, GeneratedExtensions.VolumeArchetypeExtensionTest0498.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0499))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0499, GeneratedExtensions.VolumeArchetypeExtensionTest0499.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0500))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0500, GeneratedExtensions.VolumeArchetypeExtensionTest0500.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0501))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0501, GeneratedExtensions.VolumeArchetypeExtensionTest0501.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0502))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0502, GeneratedExtensions.VolumeArchetypeExtensionTest0502.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0503))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0503, GeneratedExtensions.VolumeArchetypeExtensionTest0503.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0504))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0504, GeneratedExtensions.VolumeArchetypeExtensionTest0504.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0505))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0505, GeneratedExtensions.VolumeArchetypeExtensionTest0505.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0506))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0506, GeneratedExtensions.VolumeArchetypeExtensionTest0506.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0507))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0507, GeneratedExtensions.VolumeArchetypeExtensionTest0507.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0508))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0508, GeneratedExtensions.VolumeArchetypeExtensionTest0508.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0509))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0509, GeneratedExtensions.VolumeArchetypeExtensionTest0509.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0510))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0510, GeneratedExtensions.VolumeArchetypeExtensionTest0510.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0511))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0511, GeneratedExtensions.VolumeArchetypeExtensionTest0511.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0512))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0512, GeneratedExtensions.VolumeArchetypeExtensionTest0512.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0513))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0513, GeneratedExtensions.VolumeArchetypeExtensionTest0513.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0514))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0514, GeneratedExtensions.VolumeArchetypeExtensionTest0514.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0515))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0515, GeneratedExtensions.VolumeArchetypeExtensionTest0515.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0516))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0516, GeneratedExtensions.VolumeArchetypeExtensionTest0516.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0517))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0517, GeneratedExtensions.VolumeArchetypeExtensionTest0517.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0518))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0518, GeneratedExtensions.VolumeArchetypeExtensionTest0518.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0519))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0519, GeneratedExtensions.VolumeArchetypeExtensionTest0519.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0520))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0520, GeneratedExtensions.VolumeArchetypeExtensionTest0520.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0521))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0521, GeneratedExtensions.VolumeArchetypeExtensionTest0521.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0522))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0522, GeneratedExtensions.VolumeArchetypeExtensionTest0522.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0523))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0523, GeneratedExtensions.VolumeArchetypeExtensionTest0523.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0524))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0524, GeneratedExtensions.VolumeArchetypeExtensionTest0524.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0525))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0525, GeneratedExtensions.VolumeArchetypeExtensionTest0525.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0526))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0526, GeneratedExtensions.VolumeArchetypeExtensionTest0526.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0527))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0527, GeneratedExtensions.VolumeArchetypeExtensionTest0527.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0528))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0528, GeneratedExtensions.VolumeArchetypeExtensionTest0528.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0529))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0529, GeneratedExtensions.VolumeArchetypeExtensionTest0529.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0530))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0530, GeneratedExtensions.VolumeArchetypeExtensionTest0530.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0531))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0531, GeneratedExtensions.VolumeArchetypeExtensionTest0531.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0532))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0532, GeneratedExtensions.VolumeArchetypeExtensionTest0532.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0533))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0533, GeneratedExtensions.VolumeArchetypeExtensionTest0533.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0534))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0534, GeneratedExtensions.VolumeArchetypeExtensionTest0534.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0535))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0535, GeneratedExtensions.VolumeArchetypeExtensionTest0535.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0536))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0536, GeneratedExtensions.VolumeArchetypeExtensionTest0536.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0537))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0537, GeneratedExtensions.VolumeArchetypeExtensionTest0537.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0538))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0538, GeneratedExtensions.VolumeArchetypeExtensionTest0538.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0539))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0539, GeneratedExtensions.VolumeArchetypeExtensionTest0539.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0540))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0540, GeneratedExtensions.VolumeArchetypeExtensionTest0540.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0541))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0541, GeneratedExtensions.VolumeArchetypeExtensionTest0541.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0542))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0542, GeneratedExtensions.VolumeArchetypeExtensionTest0542.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0543))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0543, GeneratedExtensions.VolumeArchetypeExtensionTest0543.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0544))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0544, GeneratedExtensions.VolumeArchetypeExtensionTest0544.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0545))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0545, GeneratedExtensions.VolumeArchetypeExtensionTest0545.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0546))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0546, GeneratedExtensions.VolumeArchetypeExtensionTest0546.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0547))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0547, GeneratedExtensions.VolumeArchetypeExtensionTest0547.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0548))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0548, GeneratedExtensions.VolumeArchetypeExtensionTest0548.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0549))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0549, GeneratedExtensions.VolumeArchetypeExtensionTest0549.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0550))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0550, GeneratedExtensions.VolumeArchetypeExtensionTest0550.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0551))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0551, GeneratedExtensions.VolumeArchetypeExtensionTest0551.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0552))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0552, GeneratedExtensions.VolumeArchetypeExtensionTest0552.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0553))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0553, GeneratedExtensions.VolumeArchetypeExtensionTest0553.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0554))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0554, GeneratedExtensions.VolumeArchetypeExtensionTest0554.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0555))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0555, GeneratedExtensions.VolumeArchetypeExtensionTest0555.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0556))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0556, GeneratedExtensions.VolumeArchetypeExtensionTest0556.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0557))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0557, GeneratedExtensions.VolumeArchetypeExtensionTest0557.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0558))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0558, GeneratedExtensions.VolumeArchetypeExtensionTest0558.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0559))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0559, GeneratedExtensions.VolumeArchetypeExtensionTest0559.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0560))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0560, GeneratedExtensions.VolumeArchetypeExtensionTest0560.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0561))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0561, GeneratedExtensions.VolumeArchetypeExtensionTest0561.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0562))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0562, GeneratedExtensions.VolumeArchetypeExtensionTest0562.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0563))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0563, GeneratedExtensions.VolumeArchetypeExtensionTest0563.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0564))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0564, GeneratedExtensions.VolumeArchetypeExtensionTest0564.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0565))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0565, GeneratedExtensions.VolumeArchetypeExtensionTest0565.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0566))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0566, GeneratedExtensions.VolumeArchetypeExtensionTest0566.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0567))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0567, GeneratedExtensions.VolumeArchetypeExtensionTest0567.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0568))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0568, GeneratedExtensions.VolumeArchetypeExtensionTest0568.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0569))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0569, GeneratedExtensions.VolumeArchetypeExtensionTest0569.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0570))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0570, GeneratedExtensions.VolumeArchetypeExtensionTest0570.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0571))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0571, GeneratedExtensions.VolumeArchetypeExtensionTest0571.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0572))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0572, GeneratedExtensions.VolumeArchetypeExtensionTest0572.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0573))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0573, GeneratedExtensions.VolumeArchetypeExtensionTest0573.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0574))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0574, GeneratedExtensions.VolumeArchetypeExtensionTest0574.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0575))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0575, GeneratedExtensions.VolumeArchetypeExtensionTest0575.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0576))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0576, GeneratedExtensions.VolumeArchetypeExtensionTest0576.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0577))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0577, GeneratedExtensions.VolumeArchetypeExtensionTest0577.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0578))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0578, GeneratedExtensions.VolumeArchetypeExtensionTest0578.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0579))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0579, GeneratedExtensions.VolumeArchetypeExtensionTest0579.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0580))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0580, GeneratedExtensions.VolumeArchetypeExtensionTest0580.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0581))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0581, GeneratedExtensions.VolumeArchetypeExtensionTest0581.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0582))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0582, GeneratedExtensions.VolumeArchetypeExtensionTest0582.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0583))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0583, GeneratedExtensions.VolumeArchetypeExtensionTest0583.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0584))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0584, GeneratedExtensions.VolumeArchetypeExtensionTest0584.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0585))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0585, GeneratedExtensions.VolumeArchetypeExtensionTest0585.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0586))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0586, GeneratedExtensions.VolumeArchetypeExtensionTest0586.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0587))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0587, GeneratedExtensions.VolumeArchetypeExtensionTest0587.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0588))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0588, GeneratedExtensions.VolumeArchetypeExtensionTest0588.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0589))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0589, GeneratedExtensions.VolumeArchetypeExtensionTest0589.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0590))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0590, GeneratedExtensions.VolumeArchetypeExtensionTest0590.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0591))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0591, GeneratedExtensions.VolumeArchetypeExtensionTest0591.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0592))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0592, GeneratedExtensions.VolumeArchetypeExtensionTest0592.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0593))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0593, GeneratedExtensions.VolumeArchetypeExtensionTest0593.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0594))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0594, GeneratedExtensions.VolumeArchetypeExtensionTest0594.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0595))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0595, GeneratedExtensions.VolumeArchetypeExtensionTest0595.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0596))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0596, GeneratedExtensions.VolumeArchetypeExtensionTest0596.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0597))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0597, GeneratedExtensions.VolumeArchetypeExtensionTest0597.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0598))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0598, GeneratedExtensions.VolumeArchetypeExtensionTest0598.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0599))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0599, GeneratedExtensions.VolumeArchetypeExtensionTest0599.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0600))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0600, GeneratedExtensions.VolumeArchetypeExtensionTest0600.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0601))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0601, GeneratedExtensions.VolumeArchetypeExtensionTest0601.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0602))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0602, GeneratedExtensions.VolumeArchetypeExtensionTest0602.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0603))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0603, GeneratedExtensions.VolumeArchetypeExtensionTest0603.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0604))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0604, GeneratedExtensions.VolumeArchetypeExtensionTest0604.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0605))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0605, GeneratedExtensions.VolumeArchetypeExtensionTest0605.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0606))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0606, GeneratedExtensions.VolumeArchetypeExtensionTest0606.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0607))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0607, GeneratedExtensions.VolumeArchetypeExtensionTest0607.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0608))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0608, GeneratedExtensions.VolumeArchetypeExtensionTest0608.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0609))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0609, GeneratedExtensions.VolumeArchetypeExtensionTest0609.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0610))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0610, GeneratedExtensions.VolumeArchetypeExtensionTest0610.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0611))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0611, GeneratedExtensions.VolumeArchetypeExtensionTest0611.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0612))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0612, GeneratedExtensions.VolumeArchetypeExtensionTest0612.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0613))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0613, GeneratedExtensions.VolumeArchetypeExtensionTest0613.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0614))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0614, GeneratedExtensions.VolumeArchetypeExtensionTest0614.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0615))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0615, GeneratedExtensions.VolumeArchetypeExtensionTest0615.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0616))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0616, GeneratedExtensions.VolumeArchetypeExtensionTest0616.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0617))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0617, GeneratedExtensions.VolumeArchetypeExtensionTest0617.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0618))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0618, GeneratedExtensions.VolumeArchetypeExtensionTest0618.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0619))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0619, GeneratedExtensions.VolumeArchetypeExtensionTest0619.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0620))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0620, GeneratedExtensions.VolumeArchetypeExtensionTest0620.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0621))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0621, GeneratedExtensions.VolumeArchetypeExtensionTest0621.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0622))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0622, GeneratedExtensions.VolumeArchetypeExtensionTest0622.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0623))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0623, GeneratedExtensions.VolumeArchetypeExtensionTest0623.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0624))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0624, GeneratedExtensions.VolumeArchetypeExtensionTest0624.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0625))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0625, GeneratedExtensions.VolumeArchetypeExtensionTest0625.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0626))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0626, GeneratedExtensions.VolumeArchetypeExtensionTest0626.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0627))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0627, GeneratedExtensions.VolumeArchetypeExtensionTest0627.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0628))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0628, GeneratedExtensions.VolumeArchetypeExtensionTest0628.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0629))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0629, GeneratedExtensions.VolumeArchetypeExtensionTest0629.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0630))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0630, GeneratedExtensions.VolumeArchetypeExtensionTest0630.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0631))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0631, GeneratedExtensions.VolumeArchetypeExtensionTest0631.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0632))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0632, GeneratedExtensions.VolumeArchetypeExtensionTest0632.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0633))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0633, GeneratedExtensions.VolumeArchetypeExtensionTest0633.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0634))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0634, GeneratedExtensions.VolumeArchetypeExtensionTest0634.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0635))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0635, GeneratedExtensions.VolumeArchetypeExtensionTest0635.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0636))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0636, GeneratedExtensions.VolumeArchetypeExtensionTest0636.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0637))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0637, GeneratedExtensions.VolumeArchetypeExtensionTest0637.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0638))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0638, GeneratedExtensions.VolumeArchetypeExtensionTest0638.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0639))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0639, GeneratedExtensions.VolumeArchetypeExtensionTest0639.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0640))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0640, GeneratedExtensions.VolumeArchetypeExtensionTest0640.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0641))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0641, GeneratedExtensions.VolumeArchetypeExtensionTest0641.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0642))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0642, GeneratedExtensions.VolumeArchetypeExtensionTest0642.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0643))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0643, GeneratedExtensions.VolumeArchetypeExtensionTest0643.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0644))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0644, GeneratedExtensions.VolumeArchetypeExtensionTest0644.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0645))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0645, GeneratedExtensions.VolumeArchetypeExtensionTest0645.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0646))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0646, GeneratedExtensions.VolumeArchetypeExtensionTest0646.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0647))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0647, GeneratedExtensions.VolumeArchetypeExtensionTest0647.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0648))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0648, GeneratedExtensions.VolumeArchetypeExtensionTest0648.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0649))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0649, GeneratedExtensions.VolumeArchetypeExtensionTest0649.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0650))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0650, GeneratedExtensions.VolumeArchetypeExtensionTest0650.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0651))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0651, GeneratedExtensions.VolumeArchetypeExtensionTest0651.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0652))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0652, GeneratedExtensions.VolumeArchetypeExtensionTest0652.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0653))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0653, GeneratedExtensions.VolumeArchetypeExtensionTest0653.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0654))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0654, GeneratedExtensions.VolumeArchetypeExtensionTest0654.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0655))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0655, GeneratedExtensions.VolumeArchetypeExtensionTest0655.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0656))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0656, GeneratedExtensions.VolumeArchetypeExtensionTest0656.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0657))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0657, GeneratedExtensions.VolumeArchetypeExtensionTest0657.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0658))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0658, GeneratedExtensions.VolumeArchetypeExtensionTest0658.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0659))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0659, GeneratedExtensions.VolumeArchetypeExtensionTest0659.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0660))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0660, GeneratedExtensions.VolumeArchetypeExtensionTest0660.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0661))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0661, GeneratedExtensions.VolumeArchetypeExtensionTest0661.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0662))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0662, GeneratedExtensions.VolumeArchetypeExtensionTest0662.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0663))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0663, GeneratedExtensions.VolumeArchetypeExtensionTest0663.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0664))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0664, GeneratedExtensions.VolumeArchetypeExtensionTest0664.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0665))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0665, GeneratedExtensions.VolumeArchetypeExtensionTest0665.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0666))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0666, GeneratedExtensions.VolumeArchetypeExtensionTest0666.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0667))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0667, GeneratedExtensions.VolumeArchetypeExtensionTest0667.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0668))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0668, GeneratedExtensions.VolumeArchetypeExtensionTest0668.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0669))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0669, GeneratedExtensions.VolumeArchetypeExtensionTest0669.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0670))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0670, GeneratedExtensions.VolumeArchetypeExtensionTest0670.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0671))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0671, GeneratedExtensions.VolumeArchetypeExtensionTest0671.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0672))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0672, GeneratedExtensions.VolumeArchetypeExtensionTest0672.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0673))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0673, GeneratedExtensions.VolumeArchetypeExtensionTest0673.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0674))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0674, GeneratedExtensions.VolumeArchetypeExtensionTest0674.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0675))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0675, GeneratedExtensions.VolumeArchetypeExtensionTest0675.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0676))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0676, GeneratedExtensions.VolumeArchetypeExtensionTest0676.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0677))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0677, GeneratedExtensions.VolumeArchetypeExtensionTest0677.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0678))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0678, GeneratedExtensions.VolumeArchetypeExtensionTest0678.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0679))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0679, GeneratedExtensions.VolumeArchetypeExtensionTest0679.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0680))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0680, GeneratedExtensions.VolumeArchetypeExtensionTest0680.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0681))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0681, GeneratedExtensions.VolumeArchetypeExtensionTest0681.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0682))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0682, GeneratedExtensions.VolumeArchetypeExtensionTest0682.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0683))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0683, GeneratedExtensions.VolumeArchetypeExtensionTest0683.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0684))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0684, GeneratedExtensions.VolumeArchetypeExtensionTest0684.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0685))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0685, GeneratedExtensions.VolumeArchetypeExtensionTest0685.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0686))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0686, GeneratedExtensions.VolumeArchetypeExtensionTest0686.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0687))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0687, GeneratedExtensions.VolumeArchetypeExtensionTest0687.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0688))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0688, GeneratedExtensions.VolumeArchetypeExtensionTest0688.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0689))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0689, GeneratedExtensions.VolumeArchetypeExtensionTest0689.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0690))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0690, GeneratedExtensions.VolumeArchetypeExtensionTest0690.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0691))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0691, GeneratedExtensions.VolumeArchetypeExtensionTest0691.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0692))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0692, GeneratedExtensions.VolumeArchetypeExtensionTest0692.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0693))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0693, GeneratedExtensions.VolumeArchetypeExtensionTest0693.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0694))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0694, GeneratedExtensions.VolumeArchetypeExtensionTest0694.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0695))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0695, GeneratedExtensions.VolumeArchetypeExtensionTest0695.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0696))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0696, GeneratedExtensions.VolumeArchetypeExtensionTest0696.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0697))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0697, GeneratedExtensions.VolumeArchetypeExtensionTest0697.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0698))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0698, GeneratedExtensions.VolumeArchetypeExtensionTest0698.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0699))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0699, GeneratedExtensions.VolumeArchetypeExtensionTest0699.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0700))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0700, GeneratedExtensions.VolumeArchetypeExtensionTest0700.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0701))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0701, GeneratedExtensions.VolumeArchetypeExtensionTest0701.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0702))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0702, GeneratedExtensions.VolumeArchetypeExtensionTest0702.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0703))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0703, GeneratedExtensions.VolumeArchetypeExtensionTest0703.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0704))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0704, GeneratedExtensions.VolumeArchetypeExtensionTest0704.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0705))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0705, GeneratedExtensions.VolumeArchetypeExtensionTest0705.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0706))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0706, GeneratedExtensions.VolumeArchetypeExtensionTest0706.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0707))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0707, GeneratedExtensions.VolumeArchetypeExtensionTest0707.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0708))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0708, GeneratedExtensions.VolumeArchetypeExtensionTest0708.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0709))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0709, GeneratedExtensions.VolumeArchetypeExtensionTest0709.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0710))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0710, GeneratedExtensions.VolumeArchetypeExtensionTest0710.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0711))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0711, GeneratedExtensions.VolumeArchetypeExtensionTest0711.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0712))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0712, GeneratedExtensions.VolumeArchetypeExtensionTest0712.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0713))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0713, GeneratedExtensions.VolumeArchetypeExtensionTest0713.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0714))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0714, GeneratedExtensions.VolumeArchetypeExtensionTest0714.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0715))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0715, GeneratedExtensions.VolumeArchetypeExtensionTest0715.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0716))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0716, GeneratedExtensions.VolumeArchetypeExtensionTest0716.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0717))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0717, GeneratedExtensions.VolumeArchetypeExtensionTest0717.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0718))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0718, GeneratedExtensions.VolumeArchetypeExtensionTest0718.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0719))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0719, GeneratedExtensions.VolumeArchetypeExtensionTest0719.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0720))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0720, GeneratedExtensions.VolumeArchetypeExtensionTest0720.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0721))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0721, GeneratedExtensions.VolumeArchetypeExtensionTest0721.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0722))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0722, GeneratedExtensions.VolumeArchetypeExtensionTest0722.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0723))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0723, GeneratedExtensions.VolumeArchetypeExtensionTest0723.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0724))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0724, GeneratedExtensions.VolumeArchetypeExtensionTest0724.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0725))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0725, GeneratedExtensions.VolumeArchetypeExtensionTest0725.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0726))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0726, GeneratedExtensions.VolumeArchetypeExtensionTest0726.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0727))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0727, GeneratedExtensions.VolumeArchetypeExtensionTest0727.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0728))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0728, GeneratedExtensions.VolumeArchetypeExtensionTest0728.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0729))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0729, GeneratedExtensions.VolumeArchetypeExtensionTest0729.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0730))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0730, GeneratedExtensions.VolumeArchetypeExtensionTest0730.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0731))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0731, GeneratedExtensions.VolumeArchetypeExtensionTest0731.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0732))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0732, GeneratedExtensions.VolumeArchetypeExtensionTest0732.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0733))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0733, GeneratedExtensions.VolumeArchetypeExtensionTest0733.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0734))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0734, GeneratedExtensions.VolumeArchetypeExtensionTest0734.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0735))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0735, GeneratedExtensions.VolumeArchetypeExtensionTest0735.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0736))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0736, GeneratedExtensions.VolumeArchetypeExtensionTest0736.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0737))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0737, GeneratedExtensions.VolumeArchetypeExtensionTest0737.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0738))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0738, GeneratedExtensions.VolumeArchetypeExtensionTest0738.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0739))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0739, GeneratedExtensions.VolumeArchetypeExtensionTest0739.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0740))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0740, GeneratedExtensions.VolumeArchetypeExtensionTest0740.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0741))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0741, GeneratedExtensions.VolumeArchetypeExtensionTest0741.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0742))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0742, GeneratedExtensions.VolumeArchetypeExtensionTest0742.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0743))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0743, GeneratedExtensions.VolumeArchetypeExtensionTest0743.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0744))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0744, GeneratedExtensions.VolumeArchetypeExtensionTest0744.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0745))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0745, GeneratedExtensions.VolumeArchetypeExtensionTest0745.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0746))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0746, GeneratedExtensions.VolumeArchetypeExtensionTest0746.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0747))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0747, GeneratedExtensions.VolumeArchetypeExtensionTest0747.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0748))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0748, GeneratedExtensions.VolumeArchetypeExtensionTest0748.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0749))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0749, GeneratedExtensions.VolumeArchetypeExtensionTest0749.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0750))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0750, GeneratedExtensions.VolumeArchetypeExtensionTest0750.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0751))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0751, GeneratedExtensions.VolumeArchetypeExtensionTest0751.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0752))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0752, GeneratedExtensions.VolumeArchetypeExtensionTest0752.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0753))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0753, GeneratedExtensions.VolumeArchetypeExtensionTest0753.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0754))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0754, GeneratedExtensions.VolumeArchetypeExtensionTest0754.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0755))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0755, GeneratedExtensions.VolumeArchetypeExtensionTest0755.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0756))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0756, GeneratedExtensions.VolumeArchetypeExtensionTest0756.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0757))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0757, GeneratedExtensions.VolumeArchetypeExtensionTest0757.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0758))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0758, GeneratedExtensions.VolumeArchetypeExtensionTest0758.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0759))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0759, GeneratedExtensions.VolumeArchetypeExtensionTest0759.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0760))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0760, GeneratedExtensions.VolumeArchetypeExtensionTest0760.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0761))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0761, GeneratedExtensions.VolumeArchetypeExtensionTest0761.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0762))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0762, GeneratedExtensions.VolumeArchetypeExtensionTest0762.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0763))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0763, GeneratedExtensions.VolumeArchetypeExtensionTest0763.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0764))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0764, GeneratedExtensions.VolumeArchetypeExtensionTest0764.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0765))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0765, GeneratedExtensions.VolumeArchetypeExtensionTest0765.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0766))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0766, GeneratedExtensions.VolumeArchetypeExtensionTest0766.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0767))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0767, GeneratedExtensions.VolumeArchetypeExtensionTest0767.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0768))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0768, GeneratedExtensions.VolumeArchetypeExtensionTest0768.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0769))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0769, GeneratedExtensions.VolumeArchetypeExtensionTest0769.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0770))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0770, GeneratedExtensions.VolumeArchetypeExtensionTest0770.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0771))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0771, GeneratedExtensions.VolumeArchetypeExtensionTest0771.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0772))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0772, GeneratedExtensions.VolumeArchetypeExtensionTest0772.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0773))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0773, GeneratedExtensions.VolumeArchetypeExtensionTest0773.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0774))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0774, GeneratedExtensions.VolumeArchetypeExtensionTest0774.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0775))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0775, GeneratedExtensions.VolumeArchetypeExtensionTest0775.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0776))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0776, GeneratedExtensions.VolumeArchetypeExtensionTest0776.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0777))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0777, GeneratedExtensions.VolumeArchetypeExtensionTest0777.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0778))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0778, GeneratedExtensions.VolumeArchetypeExtensionTest0778.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0779))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0779, GeneratedExtensions.VolumeArchetypeExtensionTest0779.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0780))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0780, GeneratedExtensions.VolumeArchetypeExtensionTest0780.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0781))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0781, GeneratedExtensions.VolumeArchetypeExtensionTest0781.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0782))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0782, GeneratedExtensions.VolumeArchetypeExtensionTest0782.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0783))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0783, GeneratedExtensions.VolumeArchetypeExtensionTest0783.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0784))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0784, GeneratedExtensions.VolumeArchetypeExtensionTest0784.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0785))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0785, GeneratedExtensions.VolumeArchetypeExtensionTest0785.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0786))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0786, GeneratedExtensions.VolumeArchetypeExtensionTest0786.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0787))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0787, GeneratedExtensions.VolumeArchetypeExtensionTest0787.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0788))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0788, GeneratedExtensions.VolumeArchetypeExtensionTest0788.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0789))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0789, GeneratedExtensions.VolumeArchetypeExtensionTest0789.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0790))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0790, GeneratedExtensions.VolumeArchetypeExtensionTest0790.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0791))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0791, GeneratedExtensions.VolumeArchetypeExtensionTest0791.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0792))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0792, GeneratedExtensions.VolumeArchetypeExtensionTest0792.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0793))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0793, GeneratedExtensions.VolumeArchetypeExtensionTest0793.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0794))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0794, GeneratedExtensions.VolumeArchetypeExtensionTest0794.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0795))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0795, GeneratedExtensions.VolumeArchetypeExtensionTest0795.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0796))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0796, GeneratedExtensions.VolumeArchetypeExtensionTest0796.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0797))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0797, GeneratedExtensions.VolumeArchetypeExtensionTest0797.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0798))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0798, GeneratedExtensions.VolumeArchetypeExtensionTest0798.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0799))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0799, GeneratedExtensions.VolumeArchetypeExtensionTest0799.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0800))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0800, GeneratedExtensions.VolumeArchetypeExtensionTest0800.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0801))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0801, GeneratedExtensions.VolumeArchetypeExtensionTest0801.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0802))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0802, GeneratedExtensions.VolumeArchetypeExtensionTest0802.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0803))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0803, GeneratedExtensions.VolumeArchetypeExtensionTest0803.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0804))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0804, GeneratedExtensions.VolumeArchetypeExtensionTest0804.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0805))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0805, GeneratedExtensions.VolumeArchetypeExtensionTest0805.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0806))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0806, GeneratedExtensions.VolumeArchetypeExtensionTest0806.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0807))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0807, GeneratedExtensions.VolumeArchetypeExtensionTest0807.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0808))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0808, GeneratedExtensions.VolumeArchetypeExtensionTest0808.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0809))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0809, GeneratedExtensions.VolumeArchetypeExtensionTest0809.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0810))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0810, GeneratedExtensions.VolumeArchetypeExtensionTest0810.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0811))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0811, GeneratedExtensions.VolumeArchetypeExtensionTest0811.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0812))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0812, GeneratedExtensions.VolumeArchetypeExtensionTest0812.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0813))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0813, GeneratedExtensions.VolumeArchetypeExtensionTest0813.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0814))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0814, GeneratedExtensions.VolumeArchetypeExtensionTest0814.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0815))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0815, GeneratedExtensions.VolumeArchetypeExtensionTest0815.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0816))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0816, GeneratedExtensions.VolumeArchetypeExtensionTest0816.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0817))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0817, GeneratedExtensions.VolumeArchetypeExtensionTest0817.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0818))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0818, GeneratedExtensions.VolumeArchetypeExtensionTest0818.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0819))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0819, GeneratedExtensions.VolumeArchetypeExtensionTest0819.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0820))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0820, GeneratedExtensions.VolumeArchetypeExtensionTest0820.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0821))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0821, GeneratedExtensions.VolumeArchetypeExtensionTest0821.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0822))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0822, GeneratedExtensions.VolumeArchetypeExtensionTest0822.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0823))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0823, GeneratedExtensions.VolumeArchetypeExtensionTest0823.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0824))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0824, GeneratedExtensions.VolumeArchetypeExtensionTest0824.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0825))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0825, GeneratedExtensions.VolumeArchetypeExtensionTest0825.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0826))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0826, GeneratedExtensions.VolumeArchetypeExtensionTest0826.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0827))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0827, GeneratedExtensions.VolumeArchetypeExtensionTest0827.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0828))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0828, GeneratedExtensions.VolumeArchetypeExtensionTest0828.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0829))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0829, GeneratedExtensions.VolumeArchetypeExtensionTest0829.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0830))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0830, GeneratedExtensions.VolumeArchetypeExtensionTest0830.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0831))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0831, GeneratedExtensions.VolumeArchetypeExtensionTest0831.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0832))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0832, GeneratedExtensions.VolumeArchetypeExtensionTest0832.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0833))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0833, GeneratedExtensions.VolumeArchetypeExtensionTest0833.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0834))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0834, GeneratedExtensions.VolumeArchetypeExtensionTest0834.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0835))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0835, GeneratedExtensions.VolumeArchetypeExtensionTest0835.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0836))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0836, GeneratedExtensions.VolumeArchetypeExtensionTest0836.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0837))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0837, GeneratedExtensions.VolumeArchetypeExtensionTest0837.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0838))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0838, GeneratedExtensions.VolumeArchetypeExtensionTest0838.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0839))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0839, GeneratedExtensions.VolumeArchetypeExtensionTest0839.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0840))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0840, GeneratedExtensions.VolumeArchetypeExtensionTest0840.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0841))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0841, GeneratedExtensions.VolumeArchetypeExtensionTest0841.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0842))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0842, GeneratedExtensions.VolumeArchetypeExtensionTest0842.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0843))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0843, GeneratedExtensions.VolumeArchetypeExtensionTest0843.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0844))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0844, GeneratedExtensions.VolumeArchetypeExtensionTest0844.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0845))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0845, GeneratedExtensions.VolumeArchetypeExtensionTest0845.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0846))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0846, GeneratedExtensions.VolumeArchetypeExtensionTest0846.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0847))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0847, GeneratedExtensions.VolumeArchetypeExtensionTest0847.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0848))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0848, GeneratedExtensions.VolumeArchetypeExtensionTest0848.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0849))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0849, GeneratedExtensions.VolumeArchetypeExtensionTest0849.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0850))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0850, GeneratedExtensions.VolumeArchetypeExtensionTest0850.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0851))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0851, GeneratedExtensions.VolumeArchetypeExtensionTest0851.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0852))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0852, GeneratedExtensions.VolumeArchetypeExtensionTest0852.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0853))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0853, GeneratedExtensions.VolumeArchetypeExtensionTest0853.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0854))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0854, GeneratedExtensions.VolumeArchetypeExtensionTest0854.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0855))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0855, GeneratedExtensions.VolumeArchetypeExtensionTest0855.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0856))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0856, GeneratedExtensions.VolumeArchetypeExtensionTest0856.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0857))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0857, GeneratedExtensions.VolumeArchetypeExtensionTest0857.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0858))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0858, GeneratedExtensions.VolumeArchetypeExtensionTest0858.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0859))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0859, GeneratedExtensions.VolumeArchetypeExtensionTest0859.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0860))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0860, GeneratedExtensions.VolumeArchetypeExtensionTest0860.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0861))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0861, GeneratedExtensions.VolumeArchetypeExtensionTest0861.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0862))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0862, GeneratedExtensions.VolumeArchetypeExtensionTest0862.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0863))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0863, GeneratedExtensions.VolumeArchetypeExtensionTest0863.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0864))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0864, GeneratedExtensions.VolumeArchetypeExtensionTest0864.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0865))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0865, GeneratedExtensions.VolumeArchetypeExtensionTest0865.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0866))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0866, GeneratedExtensions.VolumeArchetypeExtensionTest0866.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0867))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0867, GeneratedExtensions.VolumeArchetypeExtensionTest0867.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0868))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0868, GeneratedExtensions.VolumeArchetypeExtensionTest0868.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0869))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0869, GeneratedExtensions.VolumeArchetypeExtensionTest0869.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0870))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0870, GeneratedExtensions.VolumeArchetypeExtensionTest0870.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0871))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0871, GeneratedExtensions.VolumeArchetypeExtensionTest0871.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0872))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0872, GeneratedExtensions.VolumeArchetypeExtensionTest0872.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0873))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0873, GeneratedExtensions.VolumeArchetypeExtensionTest0873.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0874))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0874, GeneratedExtensions.VolumeArchetypeExtensionTest0874.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0875))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0875, GeneratedExtensions.VolumeArchetypeExtensionTest0875.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0876))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0876, GeneratedExtensions.VolumeArchetypeExtensionTest0876.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0877))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0877, GeneratedExtensions.VolumeArchetypeExtensionTest0877.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0878))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0878, GeneratedExtensions.VolumeArchetypeExtensionTest0878.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0879))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0879, GeneratedExtensions.VolumeArchetypeExtensionTest0879.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0880))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0880, GeneratedExtensions.VolumeArchetypeExtensionTest0880.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0881))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0881, GeneratedExtensions.VolumeArchetypeExtensionTest0881.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0882))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0882, GeneratedExtensions.VolumeArchetypeExtensionTest0882.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0883))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0883, GeneratedExtensions.VolumeArchetypeExtensionTest0883.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0884))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0884, GeneratedExtensions.VolumeArchetypeExtensionTest0884.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0885))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0885, GeneratedExtensions.VolumeArchetypeExtensionTest0885.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0886))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0886, GeneratedExtensions.VolumeArchetypeExtensionTest0886.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0887))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0887, GeneratedExtensions.VolumeArchetypeExtensionTest0887.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0888))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0888, GeneratedExtensions.VolumeArchetypeExtensionTest0888.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0889))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0889, GeneratedExtensions.VolumeArchetypeExtensionTest0889.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0890))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0890, GeneratedExtensions.VolumeArchetypeExtensionTest0890.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0891))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0891, GeneratedExtensions.VolumeArchetypeExtensionTest0891.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0892))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0892, GeneratedExtensions.VolumeArchetypeExtensionTest0892.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0893))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0893, GeneratedExtensions.VolumeArchetypeExtensionTest0893.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0894))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0894, GeneratedExtensions.VolumeArchetypeExtensionTest0894.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0895))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0895, GeneratedExtensions.VolumeArchetypeExtensionTest0895.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0896))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0896, GeneratedExtensions.VolumeArchetypeExtensionTest0896.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0897))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0897, GeneratedExtensions.VolumeArchetypeExtensionTest0897.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0898))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0898, GeneratedExtensions.VolumeArchetypeExtensionTest0898.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0899))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0899, GeneratedExtensions.VolumeArchetypeExtensionTest0899.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0900))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0900, GeneratedExtensions.VolumeArchetypeExtensionTest0900.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0901))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0901, GeneratedExtensions.VolumeArchetypeExtensionTest0901.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0902))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0902, GeneratedExtensions.VolumeArchetypeExtensionTest0902.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0903))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0903, GeneratedExtensions.VolumeArchetypeExtensionTest0903.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0904))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0904, GeneratedExtensions.VolumeArchetypeExtensionTest0904.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0905))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0905, GeneratedExtensions.VolumeArchetypeExtensionTest0905.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0906))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0906, GeneratedExtensions.VolumeArchetypeExtensionTest0906.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0907))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0907, GeneratedExtensions.VolumeArchetypeExtensionTest0907.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0908))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0908, GeneratedExtensions.VolumeArchetypeExtensionTest0908.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0909))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0909, GeneratedExtensions.VolumeArchetypeExtensionTest0909.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0910))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0910, GeneratedExtensions.VolumeArchetypeExtensionTest0910.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0911))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0911, GeneratedExtensions.VolumeArchetypeExtensionTest0911.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0912))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0912, GeneratedExtensions.VolumeArchetypeExtensionTest0912.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0913))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0913, GeneratedExtensions.VolumeArchetypeExtensionTest0913.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0914))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0914, GeneratedExtensions.VolumeArchetypeExtensionTest0914.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0915))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0915, GeneratedExtensions.VolumeArchetypeExtensionTest0915.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0916))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0916, GeneratedExtensions.VolumeArchetypeExtensionTest0916.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0917))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0917, GeneratedExtensions.VolumeArchetypeExtensionTest0917.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0918))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0918, GeneratedExtensions.VolumeArchetypeExtensionTest0918.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0919))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0919, GeneratedExtensions.VolumeArchetypeExtensionTest0919.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0920))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0920, GeneratedExtensions.VolumeArchetypeExtensionTest0920.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0921))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0921, GeneratedExtensions.VolumeArchetypeExtensionTest0921.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0922))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0922, GeneratedExtensions.VolumeArchetypeExtensionTest0922.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0923))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0923, GeneratedExtensions.VolumeArchetypeExtensionTest0923.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0924))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0924, GeneratedExtensions.VolumeArchetypeExtensionTest0924.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0925))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0925, GeneratedExtensions.VolumeArchetypeExtensionTest0925.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0926))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0926, GeneratedExtensions.VolumeArchetypeExtensionTest0926.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0927))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0927, GeneratedExtensions.VolumeArchetypeExtensionTest0927.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0928))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0928, GeneratedExtensions.VolumeArchetypeExtensionTest0928.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0929))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0929, GeneratedExtensions.VolumeArchetypeExtensionTest0929.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0930))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0930, GeneratedExtensions.VolumeArchetypeExtensionTest0930.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0931))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0931, GeneratedExtensions.VolumeArchetypeExtensionTest0931.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0932))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0932, GeneratedExtensions.VolumeArchetypeExtensionTest0932.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0933))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0933, GeneratedExtensions.VolumeArchetypeExtensionTest0933.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0934))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0934, GeneratedExtensions.VolumeArchetypeExtensionTest0934.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0935))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0935, GeneratedExtensions.VolumeArchetypeExtensionTest0935.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0936))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0936, GeneratedExtensions.VolumeArchetypeExtensionTest0936.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0937))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0937, GeneratedExtensions.VolumeArchetypeExtensionTest0937.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0938))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0938, GeneratedExtensions.VolumeArchetypeExtensionTest0938.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0939))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0939, GeneratedExtensions.VolumeArchetypeExtensionTest0939.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0940))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0940, GeneratedExtensions.VolumeArchetypeExtensionTest0940.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0941))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0941, GeneratedExtensions.VolumeArchetypeExtensionTest0941.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0942))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0942, GeneratedExtensions.VolumeArchetypeExtensionTest0942.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0943))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0943, GeneratedExtensions.VolumeArchetypeExtensionTest0943.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0944))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0944, GeneratedExtensions.VolumeArchetypeExtensionTest0944.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0945))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0945, GeneratedExtensions.VolumeArchetypeExtensionTest0945.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0946))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0946, GeneratedExtensions.VolumeArchetypeExtensionTest0946.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0947))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0947, GeneratedExtensions.VolumeArchetypeExtensionTest0947.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0948))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0948, GeneratedExtensions.VolumeArchetypeExtensionTest0948.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0949))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0949, GeneratedExtensions.VolumeArchetypeExtensionTest0949.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0950))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0950, GeneratedExtensions.VolumeArchetypeExtensionTest0950.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0951))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0951, GeneratedExtensions.VolumeArchetypeExtensionTest0951.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0952))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0952, GeneratedExtensions.VolumeArchetypeExtensionTest0952.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0953))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0953, GeneratedExtensions.VolumeArchetypeExtensionTest0953.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0954))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0954, GeneratedExtensions.VolumeArchetypeExtensionTest0954.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0955))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0955, GeneratedExtensions.VolumeArchetypeExtensionTest0955.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0956))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0956, GeneratedExtensions.VolumeArchetypeExtensionTest0956.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0957))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0957, GeneratedExtensions.VolumeArchetypeExtensionTest0957.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0958))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0958, GeneratedExtensions.VolumeArchetypeExtensionTest0958.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0959))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0959, GeneratedExtensions.VolumeArchetypeExtensionTest0959.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0960))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0960, GeneratedExtensions.VolumeArchetypeExtensionTest0960.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0961))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0961, GeneratedExtensions.VolumeArchetypeExtensionTest0961.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0962))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0962, GeneratedExtensions.VolumeArchetypeExtensionTest0962.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0963))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0963, GeneratedExtensions.VolumeArchetypeExtensionTest0963.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0964))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0964, GeneratedExtensions.VolumeArchetypeExtensionTest0964.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0965))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0965, GeneratedExtensions.VolumeArchetypeExtensionTest0965.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0966))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0966, GeneratedExtensions.VolumeArchetypeExtensionTest0966.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0967))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0967, GeneratedExtensions.VolumeArchetypeExtensionTest0967.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0968))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0968, GeneratedExtensions.VolumeArchetypeExtensionTest0968.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0969))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0969, GeneratedExtensions.VolumeArchetypeExtensionTest0969.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0970))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0970, GeneratedExtensions.VolumeArchetypeExtensionTest0970.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0971))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0971, GeneratedExtensions.VolumeArchetypeExtensionTest0971.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0972))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0972, GeneratedExtensions.VolumeArchetypeExtensionTest0972.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0973))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0973, GeneratedExtensions.VolumeArchetypeExtensionTest0973.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0974))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0974, GeneratedExtensions.VolumeArchetypeExtensionTest0974.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0975))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0975, GeneratedExtensions.VolumeArchetypeExtensionTest0975.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0976))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0976, GeneratedExtensions.VolumeArchetypeExtensionTest0976.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0977))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0977, GeneratedExtensions.VolumeArchetypeExtensionTest0977.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0978))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0978, GeneratedExtensions.VolumeArchetypeExtensionTest0978.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0979))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0979, GeneratedExtensions.VolumeArchetypeExtensionTest0979.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0980))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0980, GeneratedExtensions.VolumeArchetypeExtensionTest0980.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0981))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0981, GeneratedExtensions.VolumeArchetypeExtensionTest0981.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0982))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0982, GeneratedExtensions.VolumeArchetypeExtensionTest0982.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0983))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0983, GeneratedExtensions.VolumeArchetypeExtensionTest0983.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0984))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0984, GeneratedExtensions.VolumeArchetypeExtensionTest0984.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0985))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0985, GeneratedExtensions.VolumeArchetypeExtensionTest0985.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0986))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0986, GeneratedExtensions.VolumeArchetypeExtensionTest0986.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0987))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0987, GeneratedExtensions.VolumeArchetypeExtensionTest0987.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0988))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0988, GeneratedExtensions.VolumeArchetypeExtensionTest0988.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0989))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0989, GeneratedExtensions.VolumeArchetypeExtensionTest0989.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0990))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0990, GeneratedExtensions.VolumeArchetypeExtensionTest0990.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0991))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0991, GeneratedExtensions.VolumeArchetypeExtensionTest0991.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0992))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0992, GeneratedExtensions.VolumeArchetypeExtensionTest0992.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0993))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0993, GeneratedExtensions.VolumeArchetypeExtensionTest0993.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0994))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0994, GeneratedExtensions.VolumeArchetypeExtensionTest0994.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0995))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0995, GeneratedExtensions.VolumeArchetypeExtensionTest0995.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0996))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0996, GeneratedExtensions.VolumeArchetypeExtensionTest0996.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0997))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0997, GeneratedExtensions.VolumeArchetypeExtensionTest0997.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0998))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0998, GeneratedExtensions.VolumeArchetypeExtensionTest0998.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0999))
+                {
+                    archetype.GetExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0999, GeneratedExtensions.VolumeArchetypeExtensionTest0999.Factory>(out _); return;
+                }
+                throw new Exception($"Invalid type: {type}");
+            }
+
+            private partial void ApplyGetOrAddTo(VolumeComponentArchetype archetype, Type type)
+            {
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0000))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0000, GeneratedExtensions.VolumeArchetypeExtensionTest0000.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0001))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0001, GeneratedExtensions.VolumeArchetypeExtensionTest0001.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0002))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0002, GeneratedExtensions.VolumeArchetypeExtensionTest0002.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0003))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0003, GeneratedExtensions.VolumeArchetypeExtensionTest0003.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0004))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0004, GeneratedExtensions.VolumeArchetypeExtensionTest0004.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0005))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0005, GeneratedExtensions.VolumeArchetypeExtensionTest0005.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0006))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0006, GeneratedExtensions.VolumeArchetypeExtensionTest0006.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0007))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0007, GeneratedExtensions.VolumeArchetypeExtensionTest0007.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0008))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0008, GeneratedExtensions.VolumeArchetypeExtensionTest0008.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0009))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0009, GeneratedExtensions.VolumeArchetypeExtensionTest0009.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0010))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0010, GeneratedExtensions.VolumeArchetypeExtensionTest0010.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0011))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0011, GeneratedExtensions.VolumeArchetypeExtensionTest0011.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0012))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0012, GeneratedExtensions.VolumeArchetypeExtensionTest0012.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0013))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0013, GeneratedExtensions.VolumeArchetypeExtensionTest0013.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0014))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0014, GeneratedExtensions.VolumeArchetypeExtensionTest0014.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0015))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0015, GeneratedExtensions.VolumeArchetypeExtensionTest0015.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0016))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0016, GeneratedExtensions.VolumeArchetypeExtensionTest0016.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0017))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0017, GeneratedExtensions.VolumeArchetypeExtensionTest0017.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0018))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0018, GeneratedExtensions.VolumeArchetypeExtensionTest0018.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0019))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0019, GeneratedExtensions.VolumeArchetypeExtensionTest0019.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0020))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0020, GeneratedExtensions.VolumeArchetypeExtensionTest0020.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0021))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0021, GeneratedExtensions.VolumeArchetypeExtensionTest0021.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0022))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0022, GeneratedExtensions.VolumeArchetypeExtensionTest0022.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0023))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0023, GeneratedExtensions.VolumeArchetypeExtensionTest0023.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0024))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0024, GeneratedExtensions.VolumeArchetypeExtensionTest0024.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0025))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0025, GeneratedExtensions.VolumeArchetypeExtensionTest0025.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0026))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0026, GeneratedExtensions.VolumeArchetypeExtensionTest0026.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0027))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0027, GeneratedExtensions.VolumeArchetypeExtensionTest0027.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0028))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0028, GeneratedExtensions.VolumeArchetypeExtensionTest0028.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0029))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0029, GeneratedExtensions.VolumeArchetypeExtensionTest0029.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0030))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0030, GeneratedExtensions.VolumeArchetypeExtensionTest0030.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0031))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0031, GeneratedExtensions.VolumeArchetypeExtensionTest0031.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0032))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0032, GeneratedExtensions.VolumeArchetypeExtensionTest0032.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0033))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0033, GeneratedExtensions.VolumeArchetypeExtensionTest0033.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0034))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0034, GeneratedExtensions.VolumeArchetypeExtensionTest0034.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0035))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0035, GeneratedExtensions.VolumeArchetypeExtensionTest0035.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0036))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0036, GeneratedExtensions.VolumeArchetypeExtensionTest0036.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0037))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0037, GeneratedExtensions.VolumeArchetypeExtensionTest0037.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0038))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0038, GeneratedExtensions.VolumeArchetypeExtensionTest0038.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0039))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0039, GeneratedExtensions.VolumeArchetypeExtensionTest0039.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0040))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0040, GeneratedExtensions.VolumeArchetypeExtensionTest0040.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0041))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0041, GeneratedExtensions.VolumeArchetypeExtensionTest0041.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0042))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0042, GeneratedExtensions.VolumeArchetypeExtensionTest0042.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0043))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0043, GeneratedExtensions.VolumeArchetypeExtensionTest0043.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0044))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0044, GeneratedExtensions.VolumeArchetypeExtensionTest0044.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0045))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0045, GeneratedExtensions.VolumeArchetypeExtensionTest0045.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0046))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0046, GeneratedExtensions.VolumeArchetypeExtensionTest0046.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0047))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0047, GeneratedExtensions.VolumeArchetypeExtensionTest0047.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0048))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0048, GeneratedExtensions.VolumeArchetypeExtensionTest0048.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0049))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0049, GeneratedExtensions.VolumeArchetypeExtensionTest0049.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0050))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0050, GeneratedExtensions.VolumeArchetypeExtensionTest0050.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0051))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0051, GeneratedExtensions.VolumeArchetypeExtensionTest0051.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0052))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0052, GeneratedExtensions.VolumeArchetypeExtensionTest0052.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0053))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0053, GeneratedExtensions.VolumeArchetypeExtensionTest0053.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0054))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0054, GeneratedExtensions.VolumeArchetypeExtensionTest0054.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0055))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0055, GeneratedExtensions.VolumeArchetypeExtensionTest0055.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0056))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0056, GeneratedExtensions.VolumeArchetypeExtensionTest0056.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0057))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0057, GeneratedExtensions.VolumeArchetypeExtensionTest0057.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0058))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0058, GeneratedExtensions.VolumeArchetypeExtensionTest0058.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0059))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0059, GeneratedExtensions.VolumeArchetypeExtensionTest0059.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0060))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0060, GeneratedExtensions.VolumeArchetypeExtensionTest0060.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0061))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0061, GeneratedExtensions.VolumeArchetypeExtensionTest0061.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0062))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0062, GeneratedExtensions.VolumeArchetypeExtensionTest0062.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0063))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0063, GeneratedExtensions.VolumeArchetypeExtensionTest0063.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0064))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0064, GeneratedExtensions.VolumeArchetypeExtensionTest0064.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0065))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0065, GeneratedExtensions.VolumeArchetypeExtensionTest0065.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0066))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0066, GeneratedExtensions.VolumeArchetypeExtensionTest0066.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0067))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0067, GeneratedExtensions.VolumeArchetypeExtensionTest0067.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0068))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0068, GeneratedExtensions.VolumeArchetypeExtensionTest0068.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0069))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0069, GeneratedExtensions.VolumeArchetypeExtensionTest0069.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0070))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0070, GeneratedExtensions.VolumeArchetypeExtensionTest0070.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0071))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0071, GeneratedExtensions.VolumeArchetypeExtensionTest0071.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0072))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0072, GeneratedExtensions.VolumeArchetypeExtensionTest0072.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0073))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0073, GeneratedExtensions.VolumeArchetypeExtensionTest0073.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0074))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0074, GeneratedExtensions.VolumeArchetypeExtensionTest0074.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0075))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0075, GeneratedExtensions.VolumeArchetypeExtensionTest0075.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0076))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0076, GeneratedExtensions.VolumeArchetypeExtensionTest0076.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0077))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0077, GeneratedExtensions.VolumeArchetypeExtensionTest0077.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0078))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0078, GeneratedExtensions.VolumeArchetypeExtensionTest0078.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0079))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0079, GeneratedExtensions.VolumeArchetypeExtensionTest0079.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0080))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0080, GeneratedExtensions.VolumeArchetypeExtensionTest0080.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0081))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0081, GeneratedExtensions.VolumeArchetypeExtensionTest0081.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0082))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0082, GeneratedExtensions.VolumeArchetypeExtensionTest0082.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0083))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0083, GeneratedExtensions.VolumeArchetypeExtensionTest0083.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0084))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0084, GeneratedExtensions.VolumeArchetypeExtensionTest0084.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0085))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0085, GeneratedExtensions.VolumeArchetypeExtensionTest0085.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0086))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0086, GeneratedExtensions.VolumeArchetypeExtensionTest0086.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0087))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0087, GeneratedExtensions.VolumeArchetypeExtensionTest0087.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0088))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0088, GeneratedExtensions.VolumeArchetypeExtensionTest0088.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0089))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0089, GeneratedExtensions.VolumeArchetypeExtensionTest0089.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0090))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0090, GeneratedExtensions.VolumeArchetypeExtensionTest0090.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0091))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0091, GeneratedExtensions.VolumeArchetypeExtensionTest0091.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0092))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0092, GeneratedExtensions.VolumeArchetypeExtensionTest0092.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0093))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0093, GeneratedExtensions.VolumeArchetypeExtensionTest0093.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0094))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0094, GeneratedExtensions.VolumeArchetypeExtensionTest0094.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0095))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0095, GeneratedExtensions.VolumeArchetypeExtensionTest0095.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0096))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0096, GeneratedExtensions.VolumeArchetypeExtensionTest0096.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0097))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0097, GeneratedExtensions.VolumeArchetypeExtensionTest0097.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0098))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0098, GeneratedExtensions.VolumeArchetypeExtensionTest0098.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0099))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0099, GeneratedExtensions.VolumeArchetypeExtensionTest0099.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0100))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0100, GeneratedExtensions.VolumeArchetypeExtensionTest0100.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0101))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0101, GeneratedExtensions.VolumeArchetypeExtensionTest0101.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0102))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0102, GeneratedExtensions.VolumeArchetypeExtensionTest0102.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0103))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0103, GeneratedExtensions.VolumeArchetypeExtensionTest0103.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0104))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0104, GeneratedExtensions.VolumeArchetypeExtensionTest0104.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0105))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0105, GeneratedExtensions.VolumeArchetypeExtensionTest0105.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0106))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0106, GeneratedExtensions.VolumeArchetypeExtensionTest0106.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0107))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0107, GeneratedExtensions.VolumeArchetypeExtensionTest0107.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0108))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0108, GeneratedExtensions.VolumeArchetypeExtensionTest0108.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0109))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0109, GeneratedExtensions.VolumeArchetypeExtensionTest0109.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0110))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0110, GeneratedExtensions.VolumeArchetypeExtensionTest0110.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0111))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0111, GeneratedExtensions.VolumeArchetypeExtensionTest0111.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0112))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0112, GeneratedExtensions.VolumeArchetypeExtensionTest0112.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0113))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0113, GeneratedExtensions.VolumeArchetypeExtensionTest0113.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0114))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0114, GeneratedExtensions.VolumeArchetypeExtensionTest0114.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0115))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0115, GeneratedExtensions.VolumeArchetypeExtensionTest0115.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0116))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0116, GeneratedExtensions.VolumeArchetypeExtensionTest0116.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0117))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0117, GeneratedExtensions.VolumeArchetypeExtensionTest0117.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0118))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0118, GeneratedExtensions.VolumeArchetypeExtensionTest0118.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0119))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0119, GeneratedExtensions.VolumeArchetypeExtensionTest0119.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0120))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0120, GeneratedExtensions.VolumeArchetypeExtensionTest0120.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0121))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0121, GeneratedExtensions.VolumeArchetypeExtensionTest0121.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0122))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0122, GeneratedExtensions.VolumeArchetypeExtensionTest0122.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0123))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0123, GeneratedExtensions.VolumeArchetypeExtensionTest0123.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0124))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0124, GeneratedExtensions.VolumeArchetypeExtensionTest0124.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0125))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0125, GeneratedExtensions.VolumeArchetypeExtensionTest0125.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0126))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0126, GeneratedExtensions.VolumeArchetypeExtensionTest0126.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0127))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0127, GeneratedExtensions.VolumeArchetypeExtensionTest0127.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0128))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0128, GeneratedExtensions.VolumeArchetypeExtensionTest0128.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0129))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0129, GeneratedExtensions.VolumeArchetypeExtensionTest0129.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0130))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0130, GeneratedExtensions.VolumeArchetypeExtensionTest0130.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0131))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0131, GeneratedExtensions.VolumeArchetypeExtensionTest0131.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0132))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0132, GeneratedExtensions.VolumeArchetypeExtensionTest0132.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0133))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0133, GeneratedExtensions.VolumeArchetypeExtensionTest0133.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0134))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0134, GeneratedExtensions.VolumeArchetypeExtensionTest0134.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0135))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0135, GeneratedExtensions.VolumeArchetypeExtensionTest0135.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0136))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0136, GeneratedExtensions.VolumeArchetypeExtensionTest0136.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0137))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0137, GeneratedExtensions.VolumeArchetypeExtensionTest0137.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0138))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0138, GeneratedExtensions.VolumeArchetypeExtensionTest0138.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0139))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0139, GeneratedExtensions.VolumeArchetypeExtensionTest0139.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0140))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0140, GeneratedExtensions.VolumeArchetypeExtensionTest0140.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0141))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0141, GeneratedExtensions.VolumeArchetypeExtensionTest0141.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0142))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0142, GeneratedExtensions.VolumeArchetypeExtensionTest0142.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0143))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0143, GeneratedExtensions.VolumeArchetypeExtensionTest0143.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0144))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0144, GeneratedExtensions.VolumeArchetypeExtensionTest0144.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0145))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0145, GeneratedExtensions.VolumeArchetypeExtensionTest0145.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0146))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0146, GeneratedExtensions.VolumeArchetypeExtensionTest0146.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0147))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0147, GeneratedExtensions.VolumeArchetypeExtensionTest0147.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0148))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0148, GeneratedExtensions.VolumeArchetypeExtensionTest0148.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0149))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0149, GeneratedExtensions.VolumeArchetypeExtensionTest0149.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0150))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0150, GeneratedExtensions.VolumeArchetypeExtensionTest0150.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0151))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0151, GeneratedExtensions.VolumeArchetypeExtensionTest0151.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0152))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0152, GeneratedExtensions.VolumeArchetypeExtensionTest0152.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0153))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0153, GeneratedExtensions.VolumeArchetypeExtensionTest0153.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0154))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0154, GeneratedExtensions.VolumeArchetypeExtensionTest0154.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0155))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0155, GeneratedExtensions.VolumeArchetypeExtensionTest0155.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0156))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0156, GeneratedExtensions.VolumeArchetypeExtensionTest0156.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0157))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0157, GeneratedExtensions.VolumeArchetypeExtensionTest0157.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0158))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0158, GeneratedExtensions.VolumeArchetypeExtensionTest0158.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0159))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0159, GeneratedExtensions.VolumeArchetypeExtensionTest0159.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0160))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0160, GeneratedExtensions.VolumeArchetypeExtensionTest0160.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0161))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0161, GeneratedExtensions.VolumeArchetypeExtensionTest0161.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0162))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0162, GeneratedExtensions.VolumeArchetypeExtensionTest0162.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0163))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0163, GeneratedExtensions.VolumeArchetypeExtensionTest0163.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0164))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0164, GeneratedExtensions.VolumeArchetypeExtensionTest0164.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0165))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0165, GeneratedExtensions.VolumeArchetypeExtensionTest0165.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0166))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0166, GeneratedExtensions.VolumeArchetypeExtensionTest0166.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0167))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0167, GeneratedExtensions.VolumeArchetypeExtensionTest0167.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0168))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0168, GeneratedExtensions.VolumeArchetypeExtensionTest0168.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0169))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0169, GeneratedExtensions.VolumeArchetypeExtensionTest0169.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0170))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0170, GeneratedExtensions.VolumeArchetypeExtensionTest0170.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0171))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0171, GeneratedExtensions.VolumeArchetypeExtensionTest0171.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0172))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0172, GeneratedExtensions.VolumeArchetypeExtensionTest0172.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0173))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0173, GeneratedExtensions.VolumeArchetypeExtensionTest0173.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0174))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0174, GeneratedExtensions.VolumeArchetypeExtensionTest0174.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0175))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0175, GeneratedExtensions.VolumeArchetypeExtensionTest0175.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0176))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0176, GeneratedExtensions.VolumeArchetypeExtensionTest0176.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0177))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0177, GeneratedExtensions.VolumeArchetypeExtensionTest0177.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0178))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0178, GeneratedExtensions.VolumeArchetypeExtensionTest0178.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0179))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0179, GeneratedExtensions.VolumeArchetypeExtensionTest0179.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0180))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0180, GeneratedExtensions.VolumeArchetypeExtensionTest0180.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0181))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0181, GeneratedExtensions.VolumeArchetypeExtensionTest0181.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0182))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0182, GeneratedExtensions.VolumeArchetypeExtensionTest0182.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0183))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0183, GeneratedExtensions.VolumeArchetypeExtensionTest0183.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0184))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0184, GeneratedExtensions.VolumeArchetypeExtensionTest0184.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0185))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0185, GeneratedExtensions.VolumeArchetypeExtensionTest0185.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0186))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0186, GeneratedExtensions.VolumeArchetypeExtensionTest0186.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0187))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0187, GeneratedExtensions.VolumeArchetypeExtensionTest0187.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0188))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0188, GeneratedExtensions.VolumeArchetypeExtensionTest0188.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0189))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0189, GeneratedExtensions.VolumeArchetypeExtensionTest0189.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0190))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0190, GeneratedExtensions.VolumeArchetypeExtensionTest0190.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0191))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0191, GeneratedExtensions.VolumeArchetypeExtensionTest0191.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0192))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0192, GeneratedExtensions.VolumeArchetypeExtensionTest0192.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0193))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0193, GeneratedExtensions.VolumeArchetypeExtensionTest0193.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0194))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0194, GeneratedExtensions.VolumeArchetypeExtensionTest0194.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0195))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0195, GeneratedExtensions.VolumeArchetypeExtensionTest0195.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0196))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0196, GeneratedExtensions.VolumeArchetypeExtensionTest0196.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0197))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0197, GeneratedExtensions.VolumeArchetypeExtensionTest0197.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0198))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0198, GeneratedExtensions.VolumeArchetypeExtensionTest0198.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0199))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0199, GeneratedExtensions.VolumeArchetypeExtensionTest0199.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0200))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0200, GeneratedExtensions.VolumeArchetypeExtensionTest0200.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0201))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0201, GeneratedExtensions.VolumeArchetypeExtensionTest0201.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0202))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0202, GeneratedExtensions.VolumeArchetypeExtensionTest0202.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0203))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0203, GeneratedExtensions.VolumeArchetypeExtensionTest0203.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0204))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0204, GeneratedExtensions.VolumeArchetypeExtensionTest0204.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0205))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0205, GeneratedExtensions.VolumeArchetypeExtensionTest0205.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0206))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0206, GeneratedExtensions.VolumeArchetypeExtensionTest0206.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0207))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0207, GeneratedExtensions.VolumeArchetypeExtensionTest0207.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0208))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0208, GeneratedExtensions.VolumeArchetypeExtensionTest0208.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0209))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0209, GeneratedExtensions.VolumeArchetypeExtensionTest0209.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0210))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0210, GeneratedExtensions.VolumeArchetypeExtensionTest0210.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0211))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0211, GeneratedExtensions.VolumeArchetypeExtensionTest0211.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0212))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0212, GeneratedExtensions.VolumeArchetypeExtensionTest0212.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0213))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0213, GeneratedExtensions.VolumeArchetypeExtensionTest0213.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0214))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0214, GeneratedExtensions.VolumeArchetypeExtensionTest0214.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0215))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0215, GeneratedExtensions.VolumeArchetypeExtensionTest0215.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0216))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0216, GeneratedExtensions.VolumeArchetypeExtensionTest0216.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0217))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0217, GeneratedExtensions.VolumeArchetypeExtensionTest0217.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0218))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0218, GeneratedExtensions.VolumeArchetypeExtensionTest0218.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0219))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0219, GeneratedExtensions.VolumeArchetypeExtensionTest0219.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0220))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0220, GeneratedExtensions.VolumeArchetypeExtensionTest0220.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0221))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0221, GeneratedExtensions.VolumeArchetypeExtensionTest0221.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0222))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0222, GeneratedExtensions.VolumeArchetypeExtensionTest0222.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0223))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0223, GeneratedExtensions.VolumeArchetypeExtensionTest0223.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0224))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0224, GeneratedExtensions.VolumeArchetypeExtensionTest0224.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0225))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0225, GeneratedExtensions.VolumeArchetypeExtensionTest0225.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0226))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0226, GeneratedExtensions.VolumeArchetypeExtensionTest0226.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0227))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0227, GeneratedExtensions.VolumeArchetypeExtensionTest0227.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0228))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0228, GeneratedExtensions.VolumeArchetypeExtensionTest0228.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0229))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0229, GeneratedExtensions.VolumeArchetypeExtensionTest0229.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0230))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0230, GeneratedExtensions.VolumeArchetypeExtensionTest0230.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0231))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0231, GeneratedExtensions.VolumeArchetypeExtensionTest0231.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0232))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0232, GeneratedExtensions.VolumeArchetypeExtensionTest0232.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0233))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0233, GeneratedExtensions.VolumeArchetypeExtensionTest0233.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0234))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0234, GeneratedExtensions.VolumeArchetypeExtensionTest0234.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0235))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0235, GeneratedExtensions.VolumeArchetypeExtensionTest0235.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0236))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0236, GeneratedExtensions.VolumeArchetypeExtensionTest0236.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0237))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0237, GeneratedExtensions.VolumeArchetypeExtensionTest0237.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0238))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0238, GeneratedExtensions.VolumeArchetypeExtensionTest0238.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0239))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0239, GeneratedExtensions.VolumeArchetypeExtensionTest0239.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0240))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0240, GeneratedExtensions.VolumeArchetypeExtensionTest0240.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0241))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0241, GeneratedExtensions.VolumeArchetypeExtensionTest0241.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0242))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0242, GeneratedExtensions.VolumeArchetypeExtensionTest0242.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0243))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0243, GeneratedExtensions.VolumeArchetypeExtensionTest0243.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0244))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0244, GeneratedExtensions.VolumeArchetypeExtensionTest0244.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0245))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0245, GeneratedExtensions.VolumeArchetypeExtensionTest0245.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0246))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0246, GeneratedExtensions.VolumeArchetypeExtensionTest0246.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0247))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0247, GeneratedExtensions.VolumeArchetypeExtensionTest0247.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0248))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0248, GeneratedExtensions.VolumeArchetypeExtensionTest0248.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0249))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0249, GeneratedExtensions.VolumeArchetypeExtensionTest0249.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0250))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0250, GeneratedExtensions.VolumeArchetypeExtensionTest0250.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0251))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0251, GeneratedExtensions.VolumeArchetypeExtensionTest0251.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0252))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0252, GeneratedExtensions.VolumeArchetypeExtensionTest0252.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0253))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0253, GeneratedExtensions.VolumeArchetypeExtensionTest0253.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0254))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0254, GeneratedExtensions.VolumeArchetypeExtensionTest0254.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0255))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0255, GeneratedExtensions.VolumeArchetypeExtensionTest0255.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0256))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0256, GeneratedExtensions.VolumeArchetypeExtensionTest0256.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0257))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0257, GeneratedExtensions.VolumeArchetypeExtensionTest0257.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0258))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0258, GeneratedExtensions.VolumeArchetypeExtensionTest0258.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0259))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0259, GeneratedExtensions.VolumeArchetypeExtensionTest0259.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0260))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0260, GeneratedExtensions.VolumeArchetypeExtensionTest0260.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0261))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0261, GeneratedExtensions.VolumeArchetypeExtensionTest0261.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0262))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0262, GeneratedExtensions.VolumeArchetypeExtensionTest0262.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0263))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0263, GeneratedExtensions.VolumeArchetypeExtensionTest0263.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0264))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0264, GeneratedExtensions.VolumeArchetypeExtensionTest0264.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0265))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0265, GeneratedExtensions.VolumeArchetypeExtensionTest0265.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0266))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0266, GeneratedExtensions.VolumeArchetypeExtensionTest0266.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0267))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0267, GeneratedExtensions.VolumeArchetypeExtensionTest0267.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0268))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0268, GeneratedExtensions.VolumeArchetypeExtensionTest0268.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0269))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0269, GeneratedExtensions.VolumeArchetypeExtensionTest0269.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0270))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0270, GeneratedExtensions.VolumeArchetypeExtensionTest0270.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0271))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0271, GeneratedExtensions.VolumeArchetypeExtensionTest0271.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0272))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0272, GeneratedExtensions.VolumeArchetypeExtensionTest0272.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0273))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0273, GeneratedExtensions.VolumeArchetypeExtensionTest0273.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0274))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0274, GeneratedExtensions.VolumeArchetypeExtensionTest0274.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0275))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0275, GeneratedExtensions.VolumeArchetypeExtensionTest0275.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0276))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0276, GeneratedExtensions.VolumeArchetypeExtensionTest0276.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0277))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0277, GeneratedExtensions.VolumeArchetypeExtensionTest0277.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0278))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0278, GeneratedExtensions.VolumeArchetypeExtensionTest0278.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0279))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0279, GeneratedExtensions.VolumeArchetypeExtensionTest0279.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0280))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0280, GeneratedExtensions.VolumeArchetypeExtensionTest0280.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0281))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0281, GeneratedExtensions.VolumeArchetypeExtensionTest0281.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0282))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0282, GeneratedExtensions.VolumeArchetypeExtensionTest0282.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0283))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0283, GeneratedExtensions.VolumeArchetypeExtensionTest0283.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0284))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0284, GeneratedExtensions.VolumeArchetypeExtensionTest0284.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0285))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0285, GeneratedExtensions.VolumeArchetypeExtensionTest0285.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0286))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0286, GeneratedExtensions.VolumeArchetypeExtensionTest0286.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0287))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0287, GeneratedExtensions.VolumeArchetypeExtensionTest0287.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0288))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0288, GeneratedExtensions.VolumeArchetypeExtensionTest0288.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0289))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0289, GeneratedExtensions.VolumeArchetypeExtensionTest0289.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0290))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0290, GeneratedExtensions.VolumeArchetypeExtensionTest0290.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0291))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0291, GeneratedExtensions.VolumeArchetypeExtensionTest0291.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0292))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0292, GeneratedExtensions.VolumeArchetypeExtensionTest0292.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0293))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0293, GeneratedExtensions.VolumeArchetypeExtensionTest0293.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0294))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0294, GeneratedExtensions.VolumeArchetypeExtensionTest0294.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0295))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0295, GeneratedExtensions.VolumeArchetypeExtensionTest0295.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0296))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0296, GeneratedExtensions.VolumeArchetypeExtensionTest0296.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0297))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0297, GeneratedExtensions.VolumeArchetypeExtensionTest0297.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0298))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0298, GeneratedExtensions.VolumeArchetypeExtensionTest0298.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0299))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0299, GeneratedExtensions.VolumeArchetypeExtensionTest0299.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0300))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0300, GeneratedExtensions.VolumeArchetypeExtensionTest0300.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0301))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0301, GeneratedExtensions.VolumeArchetypeExtensionTest0301.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0302))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0302, GeneratedExtensions.VolumeArchetypeExtensionTest0302.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0303))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0303, GeneratedExtensions.VolumeArchetypeExtensionTest0303.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0304))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0304, GeneratedExtensions.VolumeArchetypeExtensionTest0304.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0305))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0305, GeneratedExtensions.VolumeArchetypeExtensionTest0305.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0306))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0306, GeneratedExtensions.VolumeArchetypeExtensionTest0306.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0307))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0307, GeneratedExtensions.VolumeArchetypeExtensionTest0307.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0308))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0308, GeneratedExtensions.VolumeArchetypeExtensionTest0308.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0309))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0309, GeneratedExtensions.VolumeArchetypeExtensionTest0309.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0310))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0310, GeneratedExtensions.VolumeArchetypeExtensionTest0310.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0311))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0311, GeneratedExtensions.VolumeArchetypeExtensionTest0311.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0312))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0312, GeneratedExtensions.VolumeArchetypeExtensionTest0312.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0313))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0313, GeneratedExtensions.VolumeArchetypeExtensionTest0313.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0314))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0314, GeneratedExtensions.VolumeArchetypeExtensionTest0314.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0315))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0315, GeneratedExtensions.VolumeArchetypeExtensionTest0315.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0316))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0316, GeneratedExtensions.VolumeArchetypeExtensionTest0316.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0317))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0317, GeneratedExtensions.VolumeArchetypeExtensionTest0317.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0318))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0318, GeneratedExtensions.VolumeArchetypeExtensionTest0318.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0319))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0319, GeneratedExtensions.VolumeArchetypeExtensionTest0319.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0320))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0320, GeneratedExtensions.VolumeArchetypeExtensionTest0320.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0321))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0321, GeneratedExtensions.VolumeArchetypeExtensionTest0321.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0322))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0322, GeneratedExtensions.VolumeArchetypeExtensionTest0322.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0323))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0323, GeneratedExtensions.VolumeArchetypeExtensionTest0323.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0324))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0324, GeneratedExtensions.VolumeArchetypeExtensionTest0324.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0325))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0325, GeneratedExtensions.VolumeArchetypeExtensionTest0325.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0326))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0326, GeneratedExtensions.VolumeArchetypeExtensionTest0326.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0327))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0327, GeneratedExtensions.VolumeArchetypeExtensionTest0327.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0328))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0328, GeneratedExtensions.VolumeArchetypeExtensionTest0328.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0329))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0329, GeneratedExtensions.VolumeArchetypeExtensionTest0329.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0330))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0330, GeneratedExtensions.VolumeArchetypeExtensionTest0330.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0331))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0331, GeneratedExtensions.VolumeArchetypeExtensionTest0331.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0332))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0332, GeneratedExtensions.VolumeArchetypeExtensionTest0332.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0333))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0333, GeneratedExtensions.VolumeArchetypeExtensionTest0333.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0334))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0334, GeneratedExtensions.VolumeArchetypeExtensionTest0334.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0335))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0335, GeneratedExtensions.VolumeArchetypeExtensionTest0335.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0336))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0336, GeneratedExtensions.VolumeArchetypeExtensionTest0336.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0337))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0337, GeneratedExtensions.VolumeArchetypeExtensionTest0337.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0338))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0338, GeneratedExtensions.VolumeArchetypeExtensionTest0338.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0339))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0339, GeneratedExtensions.VolumeArchetypeExtensionTest0339.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0340))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0340, GeneratedExtensions.VolumeArchetypeExtensionTest0340.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0341))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0341, GeneratedExtensions.VolumeArchetypeExtensionTest0341.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0342))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0342, GeneratedExtensions.VolumeArchetypeExtensionTest0342.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0343))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0343, GeneratedExtensions.VolumeArchetypeExtensionTest0343.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0344))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0344, GeneratedExtensions.VolumeArchetypeExtensionTest0344.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0345))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0345, GeneratedExtensions.VolumeArchetypeExtensionTest0345.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0346))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0346, GeneratedExtensions.VolumeArchetypeExtensionTest0346.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0347))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0347, GeneratedExtensions.VolumeArchetypeExtensionTest0347.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0348))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0348, GeneratedExtensions.VolumeArchetypeExtensionTest0348.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0349))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0349, GeneratedExtensions.VolumeArchetypeExtensionTest0349.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0350))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0350, GeneratedExtensions.VolumeArchetypeExtensionTest0350.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0351))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0351, GeneratedExtensions.VolumeArchetypeExtensionTest0351.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0352))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0352, GeneratedExtensions.VolumeArchetypeExtensionTest0352.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0353))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0353, GeneratedExtensions.VolumeArchetypeExtensionTest0353.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0354))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0354, GeneratedExtensions.VolumeArchetypeExtensionTest0354.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0355))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0355, GeneratedExtensions.VolumeArchetypeExtensionTest0355.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0356))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0356, GeneratedExtensions.VolumeArchetypeExtensionTest0356.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0357))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0357, GeneratedExtensions.VolumeArchetypeExtensionTest0357.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0358))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0358, GeneratedExtensions.VolumeArchetypeExtensionTest0358.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0359))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0359, GeneratedExtensions.VolumeArchetypeExtensionTest0359.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0360))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0360, GeneratedExtensions.VolumeArchetypeExtensionTest0360.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0361))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0361, GeneratedExtensions.VolumeArchetypeExtensionTest0361.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0362))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0362, GeneratedExtensions.VolumeArchetypeExtensionTest0362.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0363))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0363, GeneratedExtensions.VolumeArchetypeExtensionTest0363.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0364))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0364, GeneratedExtensions.VolumeArchetypeExtensionTest0364.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0365))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0365, GeneratedExtensions.VolumeArchetypeExtensionTest0365.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0366))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0366, GeneratedExtensions.VolumeArchetypeExtensionTest0366.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0367))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0367, GeneratedExtensions.VolumeArchetypeExtensionTest0367.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0368))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0368, GeneratedExtensions.VolumeArchetypeExtensionTest0368.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0369))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0369, GeneratedExtensions.VolumeArchetypeExtensionTest0369.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0370))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0370, GeneratedExtensions.VolumeArchetypeExtensionTest0370.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0371))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0371, GeneratedExtensions.VolumeArchetypeExtensionTest0371.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0372))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0372, GeneratedExtensions.VolumeArchetypeExtensionTest0372.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0373))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0373, GeneratedExtensions.VolumeArchetypeExtensionTest0373.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0374))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0374, GeneratedExtensions.VolumeArchetypeExtensionTest0374.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0375))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0375, GeneratedExtensions.VolumeArchetypeExtensionTest0375.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0376))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0376, GeneratedExtensions.VolumeArchetypeExtensionTest0376.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0377))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0377, GeneratedExtensions.VolumeArchetypeExtensionTest0377.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0378))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0378, GeneratedExtensions.VolumeArchetypeExtensionTest0378.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0379))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0379, GeneratedExtensions.VolumeArchetypeExtensionTest0379.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0380))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0380, GeneratedExtensions.VolumeArchetypeExtensionTest0380.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0381))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0381, GeneratedExtensions.VolumeArchetypeExtensionTest0381.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0382))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0382, GeneratedExtensions.VolumeArchetypeExtensionTest0382.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0383))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0383, GeneratedExtensions.VolumeArchetypeExtensionTest0383.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0384))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0384, GeneratedExtensions.VolumeArchetypeExtensionTest0384.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0385))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0385, GeneratedExtensions.VolumeArchetypeExtensionTest0385.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0386))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0386, GeneratedExtensions.VolumeArchetypeExtensionTest0386.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0387))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0387, GeneratedExtensions.VolumeArchetypeExtensionTest0387.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0388))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0388, GeneratedExtensions.VolumeArchetypeExtensionTest0388.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0389))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0389, GeneratedExtensions.VolumeArchetypeExtensionTest0389.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0390))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0390, GeneratedExtensions.VolumeArchetypeExtensionTest0390.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0391))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0391, GeneratedExtensions.VolumeArchetypeExtensionTest0391.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0392))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0392, GeneratedExtensions.VolumeArchetypeExtensionTest0392.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0393))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0393, GeneratedExtensions.VolumeArchetypeExtensionTest0393.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0394))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0394, GeneratedExtensions.VolumeArchetypeExtensionTest0394.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0395))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0395, GeneratedExtensions.VolumeArchetypeExtensionTest0395.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0396))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0396, GeneratedExtensions.VolumeArchetypeExtensionTest0396.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0397))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0397, GeneratedExtensions.VolumeArchetypeExtensionTest0397.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0398))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0398, GeneratedExtensions.VolumeArchetypeExtensionTest0398.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0399))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0399, GeneratedExtensions.VolumeArchetypeExtensionTest0399.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0400))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0400, GeneratedExtensions.VolumeArchetypeExtensionTest0400.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0401))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0401, GeneratedExtensions.VolumeArchetypeExtensionTest0401.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0402))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0402, GeneratedExtensions.VolumeArchetypeExtensionTest0402.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0403))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0403, GeneratedExtensions.VolumeArchetypeExtensionTest0403.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0404))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0404, GeneratedExtensions.VolumeArchetypeExtensionTest0404.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0405))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0405, GeneratedExtensions.VolumeArchetypeExtensionTest0405.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0406))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0406, GeneratedExtensions.VolumeArchetypeExtensionTest0406.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0407))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0407, GeneratedExtensions.VolumeArchetypeExtensionTest0407.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0408))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0408, GeneratedExtensions.VolumeArchetypeExtensionTest0408.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0409))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0409, GeneratedExtensions.VolumeArchetypeExtensionTest0409.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0410))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0410, GeneratedExtensions.VolumeArchetypeExtensionTest0410.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0411))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0411, GeneratedExtensions.VolumeArchetypeExtensionTest0411.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0412))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0412, GeneratedExtensions.VolumeArchetypeExtensionTest0412.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0413))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0413, GeneratedExtensions.VolumeArchetypeExtensionTest0413.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0414))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0414, GeneratedExtensions.VolumeArchetypeExtensionTest0414.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0415))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0415, GeneratedExtensions.VolumeArchetypeExtensionTest0415.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0416))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0416, GeneratedExtensions.VolumeArchetypeExtensionTest0416.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0417))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0417, GeneratedExtensions.VolumeArchetypeExtensionTest0417.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0418))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0418, GeneratedExtensions.VolumeArchetypeExtensionTest0418.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0419))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0419, GeneratedExtensions.VolumeArchetypeExtensionTest0419.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0420))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0420, GeneratedExtensions.VolumeArchetypeExtensionTest0420.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0421))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0421, GeneratedExtensions.VolumeArchetypeExtensionTest0421.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0422))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0422, GeneratedExtensions.VolumeArchetypeExtensionTest0422.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0423))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0423, GeneratedExtensions.VolumeArchetypeExtensionTest0423.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0424))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0424, GeneratedExtensions.VolumeArchetypeExtensionTest0424.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0425))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0425, GeneratedExtensions.VolumeArchetypeExtensionTest0425.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0426))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0426, GeneratedExtensions.VolumeArchetypeExtensionTest0426.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0427))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0427, GeneratedExtensions.VolumeArchetypeExtensionTest0427.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0428))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0428, GeneratedExtensions.VolumeArchetypeExtensionTest0428.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0429))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0429, GeneratedExtensions.VolumeArchetypeExtensionTest0429.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0430))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0430, GeneratedExtensions.VolumeArchetypeExtensionTest0430.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0431))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0431, GeneratedExtensions.VolumeArchetypeExtensionTest0431.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0432))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0432, GeneratedExtensions.VolumeArchetypeExtensionTest0432.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0433))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0433, GeneratedExtensions.VolumeArchetypeExtensionTest0433.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0434))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0434, GeneratedExtensions.VolumeArchetypeExtensionTest0434.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0435))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0435, GeneratedExtensions.VolumeArchetypeExtensionTest0435.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0436))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0436, GeneratedExtensions.VolumeArchetypeExtensionTest0436.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0437))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0437, GeneratedExtensions.VolumeArchetypeExtensionTest0437.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0438))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0438, GeneratedExtensions.VolumeArchetypeExtensionTest0438.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0439))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0439, GeneratedExtensions.VolumeArchetypeExtensionTest0439.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0440))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0440, GeneratedExtensions.VolumeArchetypeExtensionTest0440.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0441))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0441, GeneratedExtensions.VolumeArchetypeExtensionTest0441.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0442))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0442, GeneratedExtensions.VolumeArchetypeExtensionTest0442.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0443))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0443, GeneratedExtensions.VolumeArchetypeExtensionTest0443.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0444))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0444, GeneratedExtensions.VolumeArchetypeExtensionTest0444.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0445))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0445, GeneratedExtensions.VolumeArchetypeExtensionTest0445.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0446))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0446, GeneratedExtensions.VolumeArchetypeExtensionTest0446.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0447))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0447, GeneratedExtensions.VolumeArchetypeExtensionTest0447.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0448))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0448, GeneratedExtensions.VolumeArchetypeExtensionTest0448.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0449))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0449, GeneratedExtensions.VolumeArchetypeExtensionTest0449.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0450))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0450, GeneratedExtensions.VolumeArchetypeExtensionTest0450.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0451))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0451, GeneratedExtensions.VolumeArchetypeExtensionTest0451.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0452))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0452, GeneratedExtensions.VolumeArchetypeExtensionTest0452.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0453))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0453, GeneratedExtensions.VolumeArchetypeExtensionTest0453.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0454))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0454, GeneratedExtensions.VolumeArchetypeExtensionTest0454.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0455))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0455, GeneratedExtensions.VolumeArchetypeExtensionTest0455.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0456))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0456, GeneratedExtensions.VolumeArchetypeExtensionTest0456.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0457))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0457, GeneratedExtensions.VolumeArchetypeExtensionTest0457.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0458))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0458, GeneratedExtensions.VolumeArchetypeExtensionTest0458.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0459))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0459, GeneratedExtensions.VolumeArchetypeExtensionTest0459.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0460))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0460, GeneratedExtensions.VolumeArchetypeExtensionTest0460.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0461))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0461, GeneratedExtensions.VolumeArchetypeExtensionTest0461.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0462))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0462, GeneratedExtensions.VolumeArchetypeExtensionTest0462.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0463))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0463, GeneratedExtensions.VolumeArchetypeExtensionTest0463.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0464))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0464, GeneratedExtensions.VolumeArchetypeExtensionTest0464.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0465))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0465, GeneratedExtensions.VolumeArchetypeExtensionTest0465.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0466))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0466, GeneratedExtensions.VolumeArchetypeExtensionTest0466.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0467))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0467, GeneratedExtensions.VolumeArchetypeExtensionTest0467.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0468))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0468, GeneratedExtensions.VolumeArchetypeExtensionTest0468.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0469))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0469, GeneratedExtensions.VolumeArchetypeExtensionTest0469.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0470))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0470, GeneratedExtensions.VolumeArchetypeExtensionTest0470.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0471))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0471, GeneratedExtensions.VolumeArchetypeExtensionTest0471.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0472))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0472, GeneratedExtensions.VolumeArchetypeExtensionTest0472.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0473))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0473, GeneratedExtensions.VolumeArchetypeExtensionTest0473.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0474))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0474, GeneratedExtensions.VolumeArchetypeExtensionTest0474.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0475))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0475, GeneratedExtensions.VolumeArchetypeExtensionTest0475.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0476))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0476, GeneratedExtensions.VolumeArchetypeExtensionTest0476.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0477))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0477, GeneratedExtensions.VolumeArchetypeExtensionTest0477.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0478))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0478, GeneratedExtensions.VolumeArchetypeExtensionTest0478.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0479))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0479, GeneratedExtensions.VolumeArchetypeExtensionTest0479.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0480))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0480, GeneratedExtensions.VolumeArchetypeExtensionTest0480.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0481))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0481, GeneratedExtensions.VolumeArchetypeExtensionTest0481.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0482))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0482, GeneratedExtensions.VolumeArchetypeExtensionTest0482.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0483))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0483, GeneratedExtensions.VolumeArchetypeExtensionTest0483.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0484))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0484, GeneratedExtensions.VolumeArchetypeExtensionTest0484.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0485))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0485, GeneratedExtensions.VolumeArchetypeExtensionTest0485.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0486))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0486, GeneratedExtensions.VolumeArchetypeExtensionTest0486.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0487))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0487, GeneratedExtensions.VolumeArchetypeExtensionTest0487.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0488))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0488, GeneratedExtensions.VolumeArchetypeExtensionTest0488.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0489))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0489, GeneratedExtensions.VolumeArchetypeExtensionTest0489.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0490))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0490, GeneratedExtensions.VolumeArchetypeExtensionTest0490.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0491))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0491, GeneratedExtensions.VolumeArchetypeExtensionTest0491.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0492))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0492, GeneratedExtensions.VolumeArchetypeExtensionTest0492.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0493))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0493, GeneratedExtensions.VolumeArchetypeExtensionTest0493.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0494))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0494, GeneratedExtensions.VolumeArchetypeExtensionTest0494.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0495))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0495, GeneratedExtensions.VolumeArchetypeExtensionTest0495.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0496))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0496, GeneratedExtensions.VolumeArchetypeExtensionTest0496.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0497))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0497, GeneratedExtensions.VolumeArchetypeExtensionTest0497.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0498))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0498, GeneratedExtensions.VolumeArchetypeExtensionTest0498.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0499))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0499, GeneratedExtensions.VolumeArchetypeExtensionTest0499.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0500))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0500, GeneratedExtensions.VolumeArchetypeExtensionTest0500.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0501))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0501, GeneratedExtensions.VolumeArchetypeExtensionTest0501.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0502))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0502, GeneratedExtensions.VolumeArchetypeExtensionTest0502.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0503))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0503, GeneratedExtensions.VolumeArchetypeExtensionTest0503.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0504))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0504, GeneratedExtensions.VolumeArchetypeExtensionTest0504.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0505))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0505, GeneratedExtensions.VolumeArchetypeExtensionTest0505.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0506))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0506, GeneratedExtensions.VolumeArchetypeExtensionTest0506.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0507))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0507, GeneratedExtensions.VolumeArchetypeExtensionTest0507.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0508))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0508, GeneratedExtensions.VolumeArchetypeExtensionTest0508.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0509))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0509, GeneratedExtensions.VolumeArchetypeExtensionTest0509.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0510))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0510, GeneratedExtensions.VolumeArchetypeExtensionTest0510.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0511))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0511, GeneratedExtensions.VolumeArchetypeExtensionTest0511.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0512))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0512, GeneratedExtensions.VolumeArchetypeExtensionTest0512.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0513))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0513, GeneratedExtensions.VolumeArchetypeExtensionTest0513.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0514))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0514, GeneratedExtensions.VolumeArchetypeExtensionTest0514.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0515))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0515, GeneratedExtensions.VolumeArchetypeExtensionTest0515.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0516))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0516, GeneratedExtensions.VolumeArchetypeExtensionTest0516.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0517))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0517, GeneratedExtensions.VolumeArchetypeExtensionTest0517.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0518))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0518, GeneratedExtensions.VolumeArchetypeExtensionTest0518.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0519))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0519, GeneratedExtensions.VolumeArchetypeExtensionTest0519.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0520))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0520, GeneratedExtensions.VolumeArchetypeExtensionTest0520.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0521))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0521, GeneratedExtensions.VolumeArchetypeExtensionTest0521.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0522))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0522, GeneratedExtensions.VolumeArchetypeExtensionTest0522.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0523))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0523, GeneratedExtensions.VolumeArchetypeExtensionTest0523.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0524))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0524, GeneratedExtensions.VolumeArchetypeExtensionTest0524.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0525))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0525, GeneratedExtensions.VolumeArchetypeExtensionTest0525.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0526))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0526, GeneratedExtensions.VolumeArchetypeExtensionTest0526.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0527))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0527, GeneratedExtensions.VolumeArchetypeExtensionTest0527.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0528))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0528, GeneratedExtensions.VolumeArchetypeExtensionTest0528.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0529))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0529, GeneratedExtensions.VolumeArchetypeExtensionTest0529.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0530))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0530, GeneratedExtensions.VolumeArchetypeExtensionTest0530.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0531))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0531, GeneratedExtensions.VolumeArchetypeExtensionTest0531.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0532))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0532, GeneratedExtensions.VolumeArchetypeExtensionTest0532.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0533))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0533, GeneratedExtensions.VolumeArchetypeExtensionTest0533.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0534))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0534, GeneratedExtensions.VolumeArchetypeExtensionTest0534.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0535))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0535, GeneratedExtensions.VolumeArchetypeExtensionTest0535.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0536))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0536, GeneratedExtensions.VolumeArchetypeExtensionTest0536.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0537))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0537, GeneratedExtensions.VolumeArchetypeExtensionTest0537.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0538))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0538, GeneratedExtensions.VolumeArchetypeExtensionTest0538.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0539))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0539, GeneratedExtensions.VolumeArchetypeExtensionTest0539.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0540))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0540, GeneratedExtensions.VolumeArchetypeExtensionTest0540.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0541))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0541, GeneratedExtensions.VolumeArchetypeExtensionTest0541.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0542))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0542, GeneratedExtensions.VolumeArchetypeExtensionTest0542.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0543))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0543, GeneratedExtensions.VolumeArchetypeExtensionTest0543.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0544))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0544, GeneratedExtensions.VolumeArchetypeExtensionTest0544.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0545))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0545, GeneratedExtensions.VolumeArchetypeExtensionTest0545.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0546))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0546, GeneratedExtensions.VolumeArchetypeExtensionTest0546.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0547))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0547, GeneratedExtensions.VolumeArchetypeExtensionTest0547.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0548))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0548, GeneratedExtensions.VolumeArchetypeExtensionTest0548.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0549))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0549, GeneratedExtensions.VolumeArchetypeExtensionTest0549.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0550))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0550, GeneratedExtensions.VolumeArchetypeExtensionTest0550.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0551))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0551, GeneratedExtensions.VolumeArchetypeExtensionTest0551.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0552))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0552, GeneratedExtensions.VolumeArchetypeExtensionTest0552.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0553))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0553, GeneratedExtensions.VolumeArchetypeExtensionTest0553.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0554))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0554, GeneratedExtensions.VolumeArchetypeExtensionTest0554.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0555))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0555, GeneratedExtensions.VolumeArchetypeExtensionTest0555.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0556))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0556, GeneratedExtensions.VolumeArchetypeExtensionTest0556.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0557))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0557, GeneratedExtensions.VolumeArchetypeExtensionTest0557.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0558))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0558, GeneratedExtensions.VolumeArchetypeExtensionTest0558.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0559))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0559, GeneratedExtensions.VolumeArchetypeExtensionTest0559.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0560))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0560, GeneratedExtensions.VolumeArchetypeExtensionTest0560.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0561))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0561, GeneratedExtensions.VolumeArchetypeExtensionTest0561.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0562))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0562, GeneratedExtensions.VolumeArchetypeExtensionTest0562.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0563))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0563, GeneratedExtensions.VolumeArchetypeExtensionTest0563.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0564))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0564, GeneratedExtensions.VolumeArchetypeExtensionTest0564.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0565))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0565, GeneratedExtensions.VolumeArchetypeExtensionTest0565.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0566))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0566, GeneratedExtensions.VolumeArchetypeExtensionTest0566.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0567))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0567, GeneratedExtensions.VolumeArchetypeExtensionTest0567.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0568))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0568, GeneratedExtensions.VolumeArchetypeExtensionTest0568.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0569))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0569, GeneratedExtensions.VolumeArchetypeExtensionTest0569.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0570))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0570, GeneratedExtensions.VolumeArchetypeExtensionTest0570.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0571))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0571, GeneratedExtensions.VolumeArchetypeExtensionTest0571.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0572))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0572, GeneratedExtensions.VolumeArchetypeExtensionTest0572.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0573))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0573, GeneratedExtensions.VolumeArchetypeExtensionTest0573.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0574))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0574, GeneratedExtensions.VolumeArchetypeExtensionTest0574.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0575))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0575, GeneratedExtensions.VolumeArchetypeExtensionTest0575.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0576))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0576, GeneratedExtensions.VolumeArchetypeExtensionTest0576.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0577))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0577, GeneratedExtensions.VolumeArchetypeExtensionTest0577.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0578))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0578, GeneratedExtensions.VolumeArchetypeExtensionTest0578.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0579))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0579, GeneratedExtensions.VolumeArchetypeExtensionTest0579.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0580))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0580, GeneratedExtensions.VolumeArchetypeExtensionTest0580.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0581))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0581, GeneratedExtensions.VolumeArchetypeExtensionTest0581.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0582))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0582, GeneratedExtensions.VolumeArchetypeExtensionTest0582.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0583))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0583, GeneratedExtensions.VolumeArchetypeExtensionTest0583.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0584))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0584, GeneratedExtensions.VolumeArchetypeExtensionTest0584.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0585))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0585, GeneratedExtensions.VolumeArchetypeExtensionTest0585.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0586))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0586, GeneratedExtensions.VolumeArchetypeExtensionTest0586.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0587))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0587, GeneratedExtensions.VolumeArchetypeExtensionTest0587.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0588))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0588, GeneratedExtensions.VolumeArchetypeExtensionTest0588.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0589))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0589, GeneratedExtensions.VolumeArchetypeExtensionTest0589.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0590))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0590, GeneratedExtensions.VolumeArchetypeExtensionTest0590.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0591))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0591, GeneratedExtensions.VolumeArchetypeExtensionTest0591.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0592))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0592, GeneratedExtensions.VolumeArchetypeExtensionTest0592.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0593))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0593, GeneratedExtensions.VolumeArchetypeExtensionTest0593.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0594))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0594, GeneratedExtensions.VolumeArchetypeExtensionTest0594.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0595))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0595, GeneratedExtensions.VolumeArchetypeExtensionTest0595.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0596))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0596, GeneratedExtensions.VolumeArchetypeExtensionTest0596.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0597))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0597, GeneratedExtensions.VolumeArchetypeExtensionTest0597.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0598))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0598, GeneratedExtensions.VolumeArchetypeExtensionTest0598.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0599))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0599, GeneratedExtensions.VolumeArchetypeExtensionTest0599.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0600))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0600, GeneratedExtensions.VolumeArchetypeExtensionTest0600.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0601))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0601, GeneratedExtensions.VolumeArchetypeExtensionTest0601.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0602))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0602, GeneratedExtensions.VolumeArchetypeExtensionTest0602.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0603))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0603, GeneratedExtensions.VolumeArchetypeExtensionTest0603.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0604))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0604, GeneratedExtensions.VolumeArchetypeExtensionTest0604.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0605))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0605, GeneratedExtensions.VolumeArchetypeExtensionTest0605.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0606))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0606, GeneratedExtensions.VolumeArchetypeExtensionTest0606.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0607))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0607, GeneratedExtensions.VolumeArchetypeExtensionTest0607.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0608))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0608, GeneratedExtensions.VolumeArchetypeExtensionTest0608.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0609))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0609, GeneratedExtensions.VolumeArchetypeExtensionTest0609.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0610))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0610, GeneratedExtensions.VolumeArchetypeExtensionTest0610.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0611))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0611, GeneratedExtensions.VolumeArchetypeExtensionTest0611.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0612))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0612, GeneratedExtensions.VolumeArchetypeExtensionTest0612.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0613))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0613, GeneratedExtensions.VolumeArchetypeExtensionTest0613.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0614))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0614, GeneratedExtensions.VolumeArchetypeExtensionTest0614.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0615))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0615, GeneratedExtensions.VolumeArchetypeExtensionTest0615.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0616))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0616, GeneratedExtensions.VolumeArchetypeExtensionTest0616.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0617))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0617, GeneratedExtensions.VolumeArchetypeExtensionTest0617.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0618))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0618, GeneratedExtensions.VolumeArchetypeExtensionTest0618.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0619))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0619, GeneratedExtensions.VolumeArchetypeExtensionTest0619.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0620))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0620, GeneratedExtensions.VolumeArchetypeExtensionTest0620.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0621))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0621, GeneratedExtensions.VolumeArchetypeExtensionTest0621.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0622))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0622, GeneratedExtensions.VolumeArchetypeExtensionTest0622.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0623))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0623, GeneratedExtensions.VolumeArchetypeExtensionTest0623.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0624))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0624, GeneratedExtensions.VolumeArchetypeExtensionTest0624.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0625))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0625, GeneratedExtensions.VolumeArchetypeExtensionTest0625.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0626))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0626, GeneratedExtensions.VolumeArchetypeExtensionTest0626.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0627))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0627, GeneratedExtensions.VolumeArchetypeExtensionTest0627.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0628))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0628, GeneratedExtensions.VolumeArchetypeExtensionTest0628.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0629))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0629, GeneratedExtensions.VolumeArchetypeExtensionTest0629.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0630))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0630, GeneratedExtensions.VolumeArchetypeExtensionTest0630.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0631))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0631, GeneratedExtensions.VolumeArchetypeExtensionTest0631.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0632))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0632, GeneratedExtensions.VolumeArchetypeExtensionTest0632.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0633))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0633, GeneratedExtensions.VolumeArchetypeExtensionTest0633.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0634))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0634, GeneratedExtensions.VolumeArchetypeExtensionTest0634.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0635))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0635, GeneratedExtensions.VolumeArchetypeExtensionTest0635.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0636))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0636, GeneratedExtensions.VolumeArchetypeExtensionTest0636.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0637))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0637, GeneratedExtensions.VolumeArchetypeExtensionTest0637.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0638))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0638, GeneratedExtensions.VolumeArchetypeExtensionTest0638.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0639))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0639, GeneratedExtensions.VolumeArchetypeExtensionTest0639.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0640))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0640, GeneratedExtensions.VolumeArchetypeExtensionTest0640.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0641))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0641, GeneratedExtensions.VolumeArchetypeExtensionTest0641.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0642))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0642, GeneratedExtensions.VolumeArchetypeExtensionTest0642.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0643))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0643, GeneratedExtensions.VolumeArchetypeExtensionTest0643.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0644))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0644, GeneratedExtensions.VolumeArchetypeExtensionTest0644.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0645))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0645, GeneratedExtensions.VolumeArchetypeExtensionTest0645.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0646))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0646, GeneratedExtensions.VolumeArchetypeExtensionTest0646.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0647))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0647, GeneratedExtensions.VolumeArchetypeExtensionTest0647.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0648))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0648, GeneratedExtensions.VolumeArchetypeExtensionTest0648.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0649))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0649, GeneratedExtensions.VolumeArchetypeExtensionTest0649.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0650))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0650, GeneratedExtensions.VolumeArchetypeExtensionTest0650.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0651))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0651, GeneratedExtensions.VolumeArchetypeExtensionTest0651.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0652))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0652, GeneratedExtensions.VolumeArchetypeExtensionTest0652.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0653))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0653, GeneratedExtensions.VolumeArchetypeExtensionTest0653.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0654))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0654, GeneratedExtensions.VolumeArchetypeExtensionTest0654.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0655))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0655, GeneratedExtensions.VolumeArchetypeExtensionTest0655.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0656))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0656, GeneratedExtensions.VolumeArchetypeExtensionTest0656.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0657))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0657, GeneratedExtensions.VolumeArchetypeExtensionTest0657.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0658))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0658, GeneratedExtensions.VolumeArchetypeExtensionTest0658.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0659))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0659, GeneratedExtensions.VolumeArchetypeExtensionTest0659.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0660))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0660, GeneratedExtensions.VolumeArchetypeExtensionTest0660.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0661))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0661, GeneratedExtensions.VolumeArchetypeExtensionTest0661.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0662))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0662, GeneratedExtensions.VolumeArchetypeExtensionTest0662.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0663))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0663, GeneratedExtensions.VolumeArchetypeExtensionTest0663.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0664))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0664, GeneratedExtensions.VolumeArchetypeExtensionTest0664.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0665))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0665, GeneratedExtensions.VolumeArchetypeExtensionTest0665.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0666))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0666, GeneratedExtensions.VolumeArchetypeExtensionTest0666.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0667))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0667, GeneratedExtensions.VolumeArchetypeExtensionTest0667.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0668))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0668, GeneratedExtensions.VolumeArchetypeExtensionTest0668.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0669))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0669, GeneratedExtensions.VolumeArchetypeExtensionTest0669.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0670))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0670, GeneratedExtensions.VolumeArchetypeExtensionTest0670.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0671))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0671, GeneratedExtensions.VolumeArchetypeExtensionTest0671.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0672))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0672, GeneratedExtensions.VolumeArchetypeExtensionTest0672.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0673))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0673, GeneratedExtensions.VolumeArchetypeExtensionTest0673.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0674))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0674, GeneratedExtensions.VolumeArchetypeExtensionTest0674.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0675))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0675, GeneratedExtensions.VolumeArchetypeExtensionTest0675.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0676))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0676, GeneratedExtensions.VolumeArchetypeExtensionTest0676.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0677))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0677, GeneratedExtensions.VolumeArchetypeExtensionTest0677.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0678))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0678, GeneratedExtensions.VolumeArchetypeExtensionTest0678.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0679))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0679, GeneratedExtensions.VolumeArchetypeExtensionTest0679.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0680))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0680, GeneratedExtensions.VolumeArchetypeExtensionTest0680.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0681))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0681, GeneratedExtensions.VolumeArchetypeExtensionTest0681.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0682))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0682, GeneratedExtensions.VolumeArchetypeExtensionTest0682.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0683))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0683, GeneratedExtensions.VolumeArchetypeExtensionTest0683.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0684))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0684, GeneratedExtensions.VolumeArchetypeExtensionTest0684.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0685))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0685, GeneratedExtensions.VolumeArchetypeExtensionTest0685.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0686))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0686, GeneratedExtensions.VolumeArchetypeExtensionTest0686.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0687))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0687, GeneratedExtensions.VolumeArchetypeExtensionTest0687.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0688))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0688, GeneratedExtensions.VolumeArchetypeExtensionTest0688.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0689))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0689, GeneratedExtensions.VolumeArchetypeExtensionTest0689.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0690))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0690, GeneratedExtensions.VolumeArchetypeExtensionTest0690.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0691))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0691, GeneratedExtensions.VolumeArchetypeExtensionTest0691.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0692))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0692, GeneratedExtensions.VolumeArchetypeExtensionTest0692.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0693))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0693, GeneratedExtensions.VolumeArchetypeExtensionTest0693.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0694))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0694, GeneratedExtensions.VolumeArchetypeExtensionTest0694.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0695))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0695, GeneratedExtensions.VolumeArchetypeExtensionTest0695.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0696))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0696, GeneratedExtensions.VolumeArchetypeExtensionTest0696.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0697))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0697, GeneratedExtensions.VolumeArchetypeExtensionTest0697.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0698))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0698, GeneratedExtensions.VolumeArchetypeExtensionTest0698.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0699))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0699, GeneratedExtensions.VolumeArchetypeExtensionTest0699.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0700))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0700, GeneratedExtensions.VolumeArchetypeExtensionTest0700.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0701))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0701, GeneratedExtensions.VolumeArchetypeExtensionTest0701.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0702))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0702, GeneratedExtensions.VolumeArchetypeExtensionTest0702.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0703))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0703, GeneratedExtensions.VolumeArchetypeExtensionTest0703.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0704))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0704, GeneratedExtensions.VolumeArchetypeExtensionTest0704.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0705))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0705, GeneratedExtensions.VolumeArchetypeExtensionTest0705.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0706))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0706, GeneratedExtensions.VolumeArchetypeExtensionTest0706.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0707))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0707, GeneratedExtensions.VolumeArchetypeExtensionTest0707.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0708))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0708, GeneratedExtensions.VolumeArchetypeExtensionTest0708.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0709))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0709, GeneratedExtensions.VolumeArchetypeExtensionTest0709.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0710))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0710, GeneratedExtensions.VolumeArchetypeExtensionTest0710.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0711))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0711, GeneratedExtensions.VolumeArchetypeExtensionTest0711.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0712))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0712, GeneratedExtensions.VolumeArchetypeExtensionTest0712.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0713))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0713, GeneratedExtensions.VolumeArchetypeExtensionTest0713.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0714))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0714, GeneratedExtensions.VolumeArchetypeExtensionTest0714.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0715))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0715, GeneratedExtensions.VolumeArchetypeExtensionTest0715.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0716))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0716, GeneratedExtensions.VolumeArchetypeExtensionTest0716.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0717))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0717, GeneratedExtensions.VolumeArchetypeExtensionTest0717.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0718))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0718, GeneratedExtensions.VolumeArchetypeExtensionTest0718.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0719))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0719, GeneratedExtensions.VolumeArchetypeExtensionTest0719.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0720))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0720, GeneratedExtensions.VolumeArchetypeExtensionTest0720.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0721))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0721, GeneratedExtensions.VolumeArchetypeExtensionTest0721.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0722))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0722, GeneratedExtensions.VolumeArchetypeExtensionTest0722.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0723))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0723, GeneratedExtensions.VolumeArchetypeExtensionTest0723.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0724))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0724, GeneratedExtensions.VolumeArchetypeExtensionTest0724.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0725))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0725, GeneratedExtensions.VolumeArchetypeExtensionTest0725.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0726))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0726, GeneratedExtensions.VolumeArchetypeExtensionTest0726.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0727))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0727, GeneratedExtensions.VolumeArchetypeExtensionTest0727.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0728))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0728, GeneratedExtensions.VolumeArchetypeExtensionTest0728.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0729))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0729, GeneratedExtensions.VolumeArchetypeExtensionTest0729.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0730))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0730, GeneratedExtensions.VolumeArchetypeExtensionTest0730.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0731))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0731, GeneratedExtensions.VolumeArchetypeExtensionTest0731.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0732))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0732, GeneratedExtensions.VolumeArchetypeExtensionTest0732.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0733))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0733, GeneratedExtensions.VolumeArchetypeExtensionTest0733.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0734))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0734, GeneratedExtensions.VolumeArchetypeExtensionTest0734.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0735))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0735, GeneratedExtensions.VolumeArchetypeExtensionTest0735.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0736))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0736, GeneratedExtensions.VolumeArchetypeExtensionTest0736.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0737))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0737, GeneratedExtensions.VolumeArchetypeExtensionTest0737.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0738))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0738, GeneratedExtensions.VolumeArchetypeExtensionTest0738.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0739))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0739, GeneratedExtensions.VolumeArchetypeExtensionTest0739.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0740))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0740, GeneratedExtensions.VolumeArchetypeExtensionTest0740.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0741))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0741, GeneratedExtensions.VolumeArchetypeExtensionTest0741.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0742))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0742, GeneratedExtensions.VolumeArchetypeExtensionTest0742.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0743))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0743, GeneratedExtensions.VolumeArchetypeExtensionTest0743.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0744))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0744, GeneratedExtensions.VolumeArchetypeExtensionTest0744.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0745))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0745, GeneratedExtensions.VolumeArchetypeExtensionTest0745.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0746))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0746, GeneratedExtensions.VolumeArchetypeExtensionTest0746.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0747))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0747, GeneratedExtensions.VolumeArchetypeExtensionTest0747.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0748))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0748, GeneratedExtensions.VolumeArchetypeExtensionTest0748.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0749))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0749, GeneratedExtensions.VolumeArchetypeExtensionTest0749.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0750))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0750, GeneratedExtensions.VolumeArchetypeExtensionTest0750.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0751))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0751, GeneratedExtensions.VolumeArchetypeExtensionTest0751.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0752))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0752, GeneratedExtensions.VolumeArchetypeExtensionTest0752.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0753))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0753, GeneratedExtensions.VolumeArchetypeExtensionTest0753.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0754))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0754, GeneratedExtensions.VolumeArchetypeExtensionTest0754.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0755))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0755, GeneratedExtensions.VolumeArchetypeExtensionTest0755.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0756))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0756, GeneratedExtensions.VolumeArchetypeExtensionTest0756.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0757))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0757, GeneratedExtensions.VolumeArchetypeExtensionTest0757.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0758))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0758, GeneratedExtensions.VolumeArchetypeExtensionTest0758.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0759))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0759, GeneratedExtensions.VolumeArchetypeExtensionTest0759.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0760))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0760, GeneratedExtensions.VolumeArchetypeExtensionTest0760.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0761))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0761, GeneratedExtensions.VolumeArchetypeExtensionTest0761.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0762))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0762, GeneratedExtensions.VolumeArchetypeExtensionTest0762.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0763))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0763, GeneratedExtensions.VolumeArchetypeExtensionTest0763.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0764))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0764, GeneratedExtensions.VolumeArchetypeExtensionTest0764.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0765))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0765, GeneratedExtensions.VolumeArchetypeExtensionTest0765.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0766))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0766, GeneratedExtensions.VolumeArchetypeExtensionTest0766.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0767))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0767, GeneratedExtensions.VolumeArchetypeExtensionTest0767.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0768))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0768, GeneratedExtensions.VolumeArchetypeExtensionTest0768.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0769))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0769, GeneratedExtensions.VolumeArchetypeExtensionTest0769.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0770))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0770, GeneratedExtensions.VolumeArchetypeExtensionTest0770.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0771))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0771, GeneratedExtensions.VolumeArchetypeExtensionTest0771.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0772))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0772, GeneratedExtensions.VolumeArchetypeExtensionTest0772.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0773))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0773, GeneratedExtensions.VolumeArchetypeExtensionTest0773.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0774))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0774, GeneratedExtensions.VolumeArchetypeExtensionTest0774.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0775))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0775, GeneratedExtensions.VolumeArchetypeExtensionTest0775.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0776))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0776, GeneratedExtensions.VolumeArchetypeExtensionTest0776.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0777))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0777, GeneratedExtensions.VolumeArchetypeExtensionTest0777.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0778))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0778, GeneratedExtensions.VolumeArchetypeExtensionTest0778.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0779))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0779, GeneratedExtensions.VolumeArchetypeExtensionTest0779.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0780))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0780, GeneratedExtensions.VolumeArchetypeExtensionTest0780.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0781))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0781, GeneratedExtensions.VolumeArchetypeExtensionTest0781.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0782))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0782, GeneratedExtensions.VolumeArchetypeExtensionTest0782.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0783))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0783, GeneratedExtensions.VolumeArchetypeExtensionTest0783.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0784))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0784, GeneratedExtensions.VolumeArchetypeExtensionTest0784.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0785))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0785, GeneratedExtensions.VolumeArchetypeExtensionTest0785.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0786))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0786, GeneratedExtensions.VolumeArchetypeExtensionTest0786.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0787))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0787, GeneratedExtensions.VolumeArchetypeExtensionTest0787.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0788))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0788, GeneratedExtensions.VolumeArchetypeExtensionTest0788.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0789))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0789, GeneratedExtensions.VolumeArchetypeExtensionTest0789.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0790))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0790, GeneratedExtensions.VolumeArchetypeExtensionTest0790.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0791))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0791, GeneratedExtensions.VolumeArchetypeExtensionTest0791.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0792))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0792, GeneratedExtensions.VolumeArchetypeExtensionTest0792.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0793))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0793, GeneratedExtensions.VolumeArchetypeExtensionTest0793.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0794))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0794, GeneratedExtensions.VolumeArchetypeExtensionTest0794.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0795))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0795, GeneratedExtensions.VolumeArchetypeExtensionTest0795.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0796))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0796, GeneratedExtensions.VolumeArchetypeExtensionTest0796.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0797))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0797, GeneratedExtensions.VolumeArchetypeExtensionTest0797.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0798))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0798, GeneratedExtensions.VolumeArchetypeExtensionTest0798.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0799))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0799, GeneratedExtensions.VolumeArchetypeExtensionTest0799.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0800))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0800, GeneratedExtensions.VolumeArchetypeExtensionTest0800.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0801))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0801, GeneratedExtensions.VolumeArchetypeExtensionTest0801.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0802))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0802, GeneratedExtensions.VolumeArchetypeExtensionTest0802.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0803))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0803, GeneratedExtensions.VolumeArchetypeExtensionTest0803.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0804))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0804, GeneratedExtensions.VolumeArchetypeExtensionTest0804.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0805))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0805, GeneratedExtensions.VolumeArchetypeExtensionTest0805.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0806))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0806, GeneratedExtensions.VolumeArchetypeExtensionTest0806.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0807))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0807, GeneratedExtensions.VolumeArchetypeExtensionTest0807.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0808))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0808, GeneratedExtensions.VolumeArchetypeExtensionTest0808.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0809))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0809, GeneratedExtensions.VolumeArchetypeExtensionTest0809.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0810))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0810, GeneratedExtensions.VolumeArchetypeExtensionTest0810.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0811))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0811, GeneratedExtensions.VolumeArchetypeExtensionTest0811.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0812))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0812, GeneratedExtensions.VolumeArchetypeExtensionTest0812.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0813))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0813, GeneratedExtensions.VolumeArchetypeExtensionTest0813.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0814))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0814, GeneratedExtensions.VolumeArchetypeExtensionTest0814.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0815))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0815, GeneratedExtensions.VolumeArchetypeExtensionTest0815.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0816))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0816, GeneratedExtensions.VolumeArchetypeExtensionTest0816.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0817))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0817, GeneratedExtensions.VolumeArchetypeExtensionTest0817.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0818))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0818, GeneratedExtensions.VolumeArchetypeExtensionTest0818.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0819))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0819, GeneratedExtensions.VolumeArchetypeExtensionTest0819.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0820))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0820, GeneratedExtensions.VolumeArchetypeExtensionTest0820.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0821))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0821, GeneratedExtensions.VolumeArchetypeExtensionTest0821.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0822))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0822, GeneratedExtensions.VolumeArchetypeExtensionTest0822.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0823))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0823, GeneratedExtensions.VolumeArchetypeExtensionTest0823.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0824))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0824, GeneratedExtensions.VolumeArchetypeExtensionTest0824.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0825))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0825, GeneratedExtensions.VolumeArchetypeExtensionTest0825.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0826))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0826, GeneratedExtensions.VolumeArchetypeExtensionTest0826.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0827))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0827, GeneratedExtensions.VolumeArchetypeExtensionTest0827.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0828))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0828, GeneratedExtensions.VolumeArchetypeExtensionTest0828.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0829))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0829, GeneratedExtensions.VolumeArchetypeExtensionTest0829.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0830))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0830, GeneratedExtensions.VolumeArchetypeExtensionTest0830.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0831))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0831, GeneratedExtensions.VolumeArchetypeExtensionTest0831.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0832))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0832, GeneratedExtensions.VolumeArchetypeExtensionTest0832.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0833))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0833, GeneratedExtensions.VolumeArchetypeExtensionTest0833.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0834))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0834, GeneratedExtensions.VolumeArchetypeExtensionTest0834.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0835))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0835, GeneratedExtensions.VolumeArchetypeExtensionTest0835.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0836))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0836, GeneratedExtensions.VolumeArchetypeExtensionTest0836.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0837))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0837, GeneratedExtensions.VolumeArchetypeExtensionTest0837.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0838))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0838, GeneratedExtensions.VolumeArchetypeExtensionTest0838.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0839))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0839, GeneratedExtensions.VolumeArchetypeExtensionTest0839.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0840))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0840, GeneratedExtensions.VolumeArchetypeExtensionTest0840.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0841))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0841, GeneratedExtensions.VolumeArchetypeExtensionTest0841.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0842))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0842, GeneratedExtensions.VolumeArchetypeExtensionTest0842.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0843))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0843, GeneratedExtensions.VolumeArchetypeExtensionTest0843.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0844))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0844, GeneratedExtensions.VolumeArchetypeExtensionTest0844.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0845))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0845, GeneratedExtensions.VolumeArchetypeExtensionTest0845.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0846))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0846, GeneratedExtensions.VolumeArchetypeExtensionTest0846.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0847))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0847, GeneratedExtensions.VolumeArchetypeExtensionTest0847.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0848))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0848, GeneratedExtensions.VolumeArchetypeExtensionTest0848.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0849))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0849, GeneratedExtensions.VolumeArchetypeExtensionTest0849.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0850))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0850, GeneratedExtensions.VolumeArchetypeExtensionTest0850.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0851))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0851, GeneratedExtensions.VolumeArchetypeExtensionTest0851.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0852))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0852, GeneratedExtensions.VolumeArchetypeExtensionTest0852.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0853))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0853, GeneratedExtensions.VolumeArchetypeExtensionTest0853.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0854))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0854, GeneratedExtensions.VolumeArchetypeExtensionTest0854.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0855))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0855, GeneratedExtensions.VolumeArchetypeExtensionTest0855.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0856))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0856, GeneratedExtensions.VolumeArchetypeExtensionTest0856.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0857))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0857, GeneratedExtensions.VolumeArchetypeExtensionTest0857.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0858))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0858, GeneratedExtensions.VolumeArchetypeExtensionTest0858.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0859))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0859, GeneratedExtensions.VolumeArchetypeExtensionTest0859.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0860))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0860, GeneratedExtensions.VolumeArchetypeExtensionTest0860.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0861))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0861, GeneratedExtensions.VolumeArchetypeExtensionTest0861.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0862))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0862, GeneratedExtensions.VolumeArchetypeExtensionTest0862.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0863))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0863, GeneratedExtensions.VolumeArchetypeExtensionTest0863.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0864))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0864, GeneratedExtensions.VolumeArchetypeExtensionTest0864.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0865))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0865, GeneratedExtensions.VolumeArchetypeExtensionTest0865.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0866))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0866, GeneratedExtensions.VolumeArchetypeExtensionTest0866.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0867))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0867, GeneratedExtensions.VolumeArchetypeExtensionTest0867.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0868))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0868, GeneratedExtensions.VolumeArchetypeExtensionTest0868.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0869))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0869, GeneratedExtensions.VolumeArchetypeExtensionTest0869.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0870))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0870, GeneratedExtensions.VolumeArchetypeExtensionTest0870.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0871))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0871, GeneratedExtensions.VolumeArchetypeExtensionTest0871.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0872))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0872, GeneratedExtensions.VolumeArchetypeExtensionTest0872.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0873))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0873, GeneratedExtensions.VolumeArchetypeExtensionTest0873.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0874))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0874, GeneratedExtensions.VolumeArchetypeExtensionTest0874.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0875))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0875, GeneratedExtensions.VolumeArchetypeExtensionTest0875.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0876))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0876, GeneratedExtensions.VolumeArchetypeExtensionTest0876.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0877))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0877, GeneratedExtensions.VolumeArchetypeExtensionTest0877.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0878))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0878, GeneratedExtensions.VolumeArchetypeExtensionTest0878.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0879))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0879, GeneratedExtensions.VolumeArchetypeExtensionTest0879.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0880))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0880, GeneratedExtensions.VolumeArchetypeExtensionTest0880.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0881))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0881, GeneratedExtensions.VolumeArchetypeExtensionTest0881.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0882))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0882, GeneratedExtensions.VolumeArchetypeExtensionTest0882.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0883))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0883, GeneratedExtensions.VolumeArchetypeExtensionTest0883.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0884))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0884, GeneratedExtensions.VolumeArchetypeExtensionTest0884.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0885))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0885, GeneratedExtensions.VolumeArchetypeExtensionTest0885.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0886))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0886, GeneratedExtensions.VolumeArchetypeExtensionTest0886.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0887))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0887, GeneratedExtensions.VolumeArchetypeExtensionTest0887.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0888))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0888, GeneratedExtensions.VolumeArchetypeExtensionTest0888.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0889))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0889, GeneratedExtensions.VolumeArchetypeExtensionTest0889.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0890))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0890, GeneratedExtensions.VolumeArchetypeExtensionTest0890.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0891))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0891, GeneratedExtensions.VolumeArchetypeExtensionTest0891.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0892))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0892, GeneratedExtensions.VolumeArchetypeExtensionTest0892.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0893))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0893, GeneratedExtensions.VolumeArchetypeExtensionTest0893.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0894))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0894, GeneratedExtensions.VolumeArchetypeExtensionTest0894.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0895))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0895, GeneratedExtensions.VolumeArchetypeExtensionTest0895.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0896))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0896, GeneratedExtensions.VolumeArchetypeExtensionTest0896.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0897))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0897, GeneratedExtensions.VolumeArchetypeExtensionTest0897.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0898))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0898, GeneratedExtensions.VolumeArchetypeExtensionTest0898.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0899))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0899, GeneratedExtensions.VolumeArchetypeExtensionTest0899.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0900))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0900, GeneratedExtensions.VolumeArchetypeExtensionTest0900.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0901))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0901, GeneratedExtensions.VolumeArchetypeExtensionTest0901.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0902))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0902, GeneratedExtensions.VolumeArchetypeExtensionTest0902.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0903))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0903, GeneratedExtensions.VolumeArchetypeExtensionTest0903.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0904))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0904, GeneratedExtensions.VolumeArchetypeExtensionTest0904.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0905))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0905, GeneratedExtensions.VolumeArchetypeExtensionTest0905.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0906))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0906, GeneratedExtensions.VolumeArchetypeExtensionTest0906.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0907))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0907, GeneratedExtensions.VolumeArchetypeExtensionTest0907.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0908))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0908, GeneratedExtensions.VolumeArchetypeExtensionTest0908.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0909))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0909, GeneratedExtensions.VolumeArchetypeExtensionTest0909.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0910))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0910, GeneratedExtensions.VolumeArchetypeExtensionTest0910.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0911))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0911, GeneratedExtensions.VolumeArchetypeExtensionTest0911.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0912))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0912, GeneratedExtensions.VolumeArchetypeExtensionTest0912.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0913))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0913, GeneratedExtensions.VolumeArchetypeExtensionTest0913.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0914))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0914, GeneratedExtensions.VolumeArchetypeExtensionTest0914.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0915))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0915, GeneratedExtensions.VolumeArchetypeExtensionTest0915.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0916))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0916, GeneratedExtensions.VolumeArchetypeExtensionTest0916.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0917))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0917, GeneratedExtensions.VolumeArchetypeExtensionTest0917.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0918))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0918, GeneratedExtensions.VolumeArchetypeExtensionTest0918.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0919))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0919, GeneratedExtensions.VolumeArchetypeExtensionTest0919.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0920))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0920, GeneratedExtensions.VolumeArchetypeExtensionTest0920.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0921))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0921, GeneratedExtensions.VolumeArchetypeExtensionTest0921.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0922))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0922, GeneratedExtensions.VolumeArchetypeExtensionTest0922.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0923))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0923, GeneratedExtensions.VolumeArchetypeExtensionTest0923.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0924))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0924, GeneratedExtensions.VolumeArchetypeExtensionTest0924.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0925))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0925, GeneratedExtensions.VolumeArchetypeExtensionTest0925.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0926))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0926, GeneratedExtensions.VolumeArchetypeExtensionTest0926.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0927))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0927, GeneratedExtensions.VolumeArchetypeExtensionTest0927.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0928))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0928, GeneratedExtensions.VolumeArchetypeExtensionTest0928.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0929))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0929, GeneratedExtensions.VolumeArchetypeExtensionTest0929.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0930))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0930, GeneratedExtensions.VolumeArchetypeExtensionTest0930.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0931))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0931, GeneratedExtensions.VolumeArchetypeExtensionTest0931.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0932))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0932, GeneratedExtensions.VolumeArchetypeExtensionTest0932.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0933))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0933, GeneratedExtensions.VolumeArchetypeExtensionTest0933.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0934))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0934, GeneratedExtensions.VolumeArchetypeExtensionTest0934.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0935))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0935, GeneratedExtensions.VolumeArchetypeExtensionTest0935.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0936))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0936, GeneratedExtensions.VolumeArchetypeExtensionTest0936.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0937))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0937, GeneratedExtensions.VolumeArchetypeExtensionTest0937.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0938))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0938, GeneratedExtensions.VolumeArchetypeExtensionTest0938.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0939))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0939, GeneratedExtensions.VolumeArchetypeExtensionTest0939.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0940))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0940, GeneratedExtensions.VolumeArchetypeExtensionTest0940.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0941))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0941, GeneratedExtensions.VolumeArchetypeExtensionTest0941.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0942))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0942, GeneratedExtensions.VolumeArchetypeExtensionTest0942.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0943))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0943, GeneratedExtensions.VolumeArchetypeExtensionTest0943.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0944))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0944, GeneratedExtensions.VolumeArchetypeExtensionTest0944.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0945))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0945, GeneratedExtensions.VolumeArchetypeExtensionTest0945.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0946))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0946, GeneratedExtensions.VolumeArchetypeExtensionTest0946.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0947))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0947, GeneratedExtensions.VolumeArchetypeExtensionTest0947.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0948))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0948, GeneratedExtensions.VolumeArchetypeExtensionTest0948.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0949))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0949, GeneratedExtensions.VolumeArchetypeExtensionTest0949.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0950))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0950, GeneratedExtensions.VolumeArchetypeExtensionTest0950.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0951))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0951, GeneratedExtensions.VolumeArchetypeExtensionTest0951.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0952))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0952, GeneratedExtensions.VolumeArchetypeExtensionTest0952.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0953))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0953, GeneratedExtensions.VolumeArchetypeExtensionTest0953.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0954))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0954, GeneratedExtensions.VolumeArchetypeExtensionTest0954.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0955))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0955, GeneratedExtensions.VolumeArchetypeExtensionTest0955.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0956))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0956, GeneratedExtensions.VolumeArchetypeExtensionTest0956.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0957))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0957, GeneratedExtensions.VolumeArchetypeExtensionTest0957.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0958))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0958, GeneratedExtensions.VolumeArchetypeExtensionTest0958.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0959))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0959, GeneratedExtensions.VolumeArchetypeExtensionTest0959.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0960))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0960, GeneratedExtensions.VolumeArchetypeExtensionTest0960.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0961))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0961, GeneratedExtensions.VolumeArchetypeExtensionTest0961.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0962))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0962, GeneratedExtensions.VolumeArchetypeExtensionTest0962.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0963))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0963, GeneratedExtensions.VolumeArchetypeExtensionTest0963.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0964))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0964, GeneratedExtensions.VolumeArchetypeExtensionTest0964.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0965))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0965, GeneratedExtensions.VolumeArchetypeExtensionTest0965.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0966))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0966, GeneratedExtensions.VolumeArchetypeExtensionTest0966.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0967))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0967, GeneratedExtensions.VolumeArchetypeExtensionTest0967.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0968))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0968, GeneratedExtensions.VolumeArchetypeExtensionTest0968.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0969))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0969, GeneratedExtensions.VolumeArchetypeExtensionTest0969.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0970))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0970, GeneratedExtensions.VolumeArchetypeExtensionTest0970.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0971))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0971, GeneratedExtensions.VolumeArchetypeExtensionTest0971.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0972))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0972, GeneratedExtensions.VolumeArchetypeExtensionTest0972.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0973))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0973, GeneratedExtensions.VolumeArchetypeExtensionTest0973.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0974))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0974, GeneratedExtensions.VolumeArchetypeExtensionTest0974.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0975))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0975, GeneratedExtensions.VolumeArchetypeExtensionTest0975.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0976))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0976, GeneratedExtensions.VolumeArchetypeExtensionTest0976.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0977))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0977, GeneratedExtensions.VolumeArchetypeExtensionTest0977.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0978))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0978, GeneratedExtensions.VolumeArchetypeExtensionTest0978.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0979))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0979, GeneratedExtensions.VolumeArchetypeExtensionTest0979.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0980))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0980, GeneratedExtensions.VolumeArchetypeExtensionTest0980.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0981))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0981, GeneratedExtensions.VolumeArchetypeExtensionTest0981.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0982))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0982, GeneratedExtensions.VolumeArchetypeExtensionTest0982.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0983))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0983, GeneratedExtensions.VolumeArchetypeExtensionTest0983.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0984))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0984, GeneratedExtensions.VolumeArchetypeExtensionTest0984.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0985))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0985, GeneratedExtensions.VolumeArchetypeExtensionTest0985.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0986))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0986, GeneratedExtensions.VolumeArchetypeExtensionTest0986.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0987))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0987, GeneratedExtensions.VolumeArchetypeExtensionTest0987.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0988))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0988, GeneratedExtensions.VolumeArchetypeExtensionTest0988.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0989))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0989, GeneratedExtensions.VolumeArchetypeExtensionTest0989.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0990))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0990, GeneratedExtensions.VolumeArchetypeExtensionTest0990.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0991))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0991, GeneratedExtensions.VolumeArchetypeExtensionTest0991.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0992))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0992, GeneratedExtensions.VolumeArchetypeExtensionTest0992.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0993))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0993, GeneratedExtensions.VolumeArchetypeExtensionTest0993.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0994))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0994, GeneratedExtensions.VolumeArchetypeExtensionTest0994.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0995))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0995, GeneratedExtensions.VolumeArchetypeExtensionTest0995.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0996))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0996, GeneratedExtensions.VolumeArchetypeExtensionTest0996.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0997))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0997, GeneratedExtensions.VolumeArchetypeExtensionTest0997.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0998))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0998, GeneratedExtensions.VolumeArchetypeExtensionTest0998.Factory>(out _); return;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0999))
+                {
+                    archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0999, GeneratedExtensions.VolumeArchetypeExtensionTest0999.Factory>(out _); return;
+                }
+                throw new Exception($"Invalid type: {type}");
+            }
+
+            private partial bool CheckGetTo(VolumeComponentArchetype archetype, Type type)
+            {
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0000))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0001))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0002))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0003))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0004))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0005))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0006))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0007))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0008))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0009))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0010))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0011))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0012))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0013))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0014))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0015))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0016))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0017))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0018))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0019))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0020))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0021))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0022))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0023))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0024))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0025))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0026))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0027))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0028))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0029))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0030))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0031))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0032))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0033))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0034))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0035))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0036))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0037))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0038))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0039))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0040))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0041))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0042))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0043))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0044))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0045))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0046))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0047))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0048))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0049))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0050))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0051))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0052))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0053))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0054))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0055))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0056))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0057))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0058))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0059))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0060))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0061))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0062))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0063))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0064))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0065))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0066))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0067))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0068))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0069))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0070))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0071))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0072))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0073))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0074))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0075))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0076))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0077))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0078))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0079))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0080))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0081))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0082))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0083))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0084))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0085))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0086))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0087))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0088))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0089))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0090))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0091))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0092))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0093))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0094))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0095))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0096))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0097))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0098))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0099))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0100))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0101))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0102))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0103))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0104))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0105))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0106))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0107))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0108))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0109))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0110))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0111))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0112))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0113))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0114))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0115))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0116))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0117))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0118))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0119))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0120))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0121))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0122))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0123))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0124))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0125))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0126))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0127))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0128))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0129))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0130))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0131))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0132))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0133))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0134))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0135))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0136))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0137))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0138))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0139))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0140))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0141))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0142))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0143))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0144))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0145))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0146))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0147))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0148))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0149))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0150))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0151))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0152))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0153))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0154))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0155))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0156))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0157))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0158))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0159))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0160))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0161))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0162))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0163))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0164))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0165))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0166))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0167))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0168))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0169))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0170))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0171))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0172))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0173))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0174))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0175))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0176))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0177))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0178))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0179))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0180))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0181))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0182))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0183))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0184))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0185))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0186))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0187))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0188))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0189))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0190))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0191))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0192))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0193))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0194))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0195))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0196))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0197))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0198))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0199))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0200))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0201))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0202))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0203))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0204))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0205))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0206))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0207))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0208))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0209))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0210))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0211))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0212))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0213))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0214))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0215))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0216))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0217))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0218))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0219))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0220))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0221))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0222))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0223))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0224))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0225))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0226))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0227))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0228))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0229))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0230))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0231))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0232))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0233))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0234))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0235))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0236))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0237))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0238))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0239))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0240))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0241))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0242))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0243))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0244))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0245))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0246))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0247))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0248))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0249))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0250))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0251))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0252))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0253))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0254))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0255))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0256))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0257))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0258))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0259))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0260))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0261))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0262))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0263))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0264))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0265))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0266))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0267))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0268))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0269))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0270))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0271))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0272))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0273))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0274))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0275))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0276))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0277))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0278))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0279))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0280))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0281))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0282))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0283))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0284))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0285))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0286))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0287))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0288))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0289))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0290))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0291))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0292))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0293))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0294))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0295))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0296))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0297))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0298))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0299))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0300))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0301))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0302))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0303))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0304))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0305))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0306))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0307))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0308))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0309))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0310))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0311))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0312))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0313))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0314))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0315))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0316))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0317))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0318))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0319))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0320))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0321))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0322))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0323))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0324))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0325))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0326))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0327))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0328))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0329))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0330))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0331))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0332))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0333))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0334))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0335))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0336))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0337))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0338))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0339))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0340))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0341))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0342))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0343))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0344))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0345))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0346))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0347))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0348))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0349))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0350))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0351))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0352))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0353))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0354))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0355))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0356))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0357))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0358))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0359))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0360))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0361))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0362))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0363))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0364))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0365))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0366))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0367))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0368))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0369))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0370))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0371))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0372))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0373))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0374))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0375))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0376))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0377))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0378))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0379))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0380))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0381))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0382))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0383))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0384))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0385))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0386))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0387))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0388))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0389))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0390))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0391))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0392))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0393))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0394))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0395))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0396))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0397))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0398))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0399))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0400))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0401))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0402))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0403))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0404))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0405))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0406))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0407))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0408))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0409))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0410))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0411))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0412))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0413))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0414))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0415))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0416))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0417))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0418))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0419))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0420))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0421))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0422))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0423))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0424))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0425))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0426))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0427))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0428))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0429))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0430))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0431))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0432))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0433))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0434))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0435))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0436))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0437))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0438))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0439))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0440))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0441))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0442))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0443))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0444))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0445))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0446))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0447))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0448))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0449))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0450))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0451))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0452))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0453))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0454))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0455))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0456))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0457))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0458))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0459))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0460))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0461))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0462))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0463))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0464))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0465))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0466))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0467))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0468))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0469))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0470))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0471))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0472))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0473))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0474))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0475))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0476))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0477))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0478))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0479))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0480))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0481))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0482))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0483))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0484))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0485))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0486))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0487))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0488))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0489))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0490))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0491))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0492))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0493))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0494))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0495))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0496))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0497))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0498))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0499))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0500))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0501))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0502))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0503))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0504))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0505))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0506))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0507))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0508))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0509))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0510))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0511))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0512))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0513))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0514))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0515))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0516))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0517))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0518))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0519))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0520))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0521))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0522))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0523))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0524))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0525))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0526))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0527))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0528))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0529))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0530))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0531))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0532))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0533))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0534))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0535))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0536))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0537))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0538))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0539))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0540))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0541))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0542))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0543))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0544))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0545))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0546))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0547))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0548))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0549))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0550))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0551))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0552))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0553))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0554))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0555))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0556))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0557))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0558))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0559))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0560))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0561))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0562))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0563))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0564))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0565))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0566))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0567))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0568))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0569))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0570))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0571))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0572))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0573))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0574))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0575))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0576))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0577))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0578))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0579))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0580))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0581))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0582))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0583))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0584))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0585))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0586))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0587))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0588))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0589))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0590))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0591))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0592))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0593))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0594))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0595))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0596))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0597))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0598))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0599))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0600))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0601))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0602))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0603))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0604))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0605))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0606))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0607))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0608))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0609))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0610))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0611))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0612))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0613))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0614))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0615))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0616))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0617))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0618))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0619))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0620))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0621))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0622))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0623))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0624))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0625))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0626))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0627))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0628))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0629))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0630))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0631))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0632))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0633))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0634))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0635))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0636))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0637))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0638))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0639))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0640))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0641))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0642))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0643))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0644))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0645))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0646))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0647))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0648))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0649))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0650))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0651))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0652))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0653))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0654))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0655))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0656))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0657))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0658))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0659))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0660))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0661))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0662))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0663))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0664))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0665))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0666))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0667))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0668))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0669))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0670))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0671))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0672))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0673))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0674))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0675))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0676))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0677))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0678))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0679))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0680))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0681))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0682))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0683))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0684))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0685))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0686))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0687))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0688))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0689))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0690))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0691))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0692))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0693))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0694))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0695))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0696))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0697))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0698))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0699))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0700))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0701))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0702))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0703))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0704))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0705))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0706))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0707))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0708))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0709))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0710))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0711))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0712))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0713))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0714))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0715))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0716))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0717))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0718))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0719))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0720))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0721))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0722))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0723))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0724))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0725))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0726))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0727))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0728))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0729))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0730))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0731))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0732))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0733))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0734))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0735))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0736))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0737))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0738))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0739))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0740))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0741))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0742))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0743))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0744))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0745))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0746))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0747))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0748))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0749))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0750))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0751))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0752))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0753))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0754))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0755))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0756))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0757))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0758))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0759))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0760))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0761))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0762))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0763))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0764))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0765))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0766))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0767))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0768))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0769))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0770))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0771))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0772))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0773))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0774))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0775))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0776))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0777))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0778))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0779))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0780))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0781))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0782))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0783))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0784))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0785))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0786))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0787))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0788))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0789))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0790))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0791))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0792))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0793))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0794))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0795))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0796))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0797))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0798))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0799))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0800))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0801))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0802))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0803))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0804))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0805))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0806))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0807))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0808))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0809))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0810))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0811))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0812))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0813))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0814))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0815))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0816))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0817))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0818))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0819))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0820))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0821))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0822))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0823))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0824))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0825))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0826))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0827))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0828))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0829))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0830))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0831))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0832))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0833))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0834))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0835))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0836))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0837))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0838))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0839))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0840))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0841))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0842))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0843))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0844))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0845))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0846))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0847))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0848))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0849))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0850))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0851))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0852))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0853))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0854))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0855))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0856))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0857))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0858))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0859))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0860))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0861))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0862))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0863))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0864))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0865))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0866))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0867))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0868))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0869))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0870))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0871))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0872))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0873))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0874))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0875))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0876))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0877))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0878))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0879))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0880))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0881))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0882))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0883))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0884))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0885))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0886))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0887))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0888))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0889))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0890))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0891))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0892))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0893))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0894))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0895))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0896))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0897))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0898))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0899))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0900))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0901))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0902))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0903))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0904))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0905))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0906))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0907))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0908))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0909))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0910))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0911))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0912))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0913))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0914))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0915))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0916))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0917))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0918))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0919))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0920))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0921))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0922))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0923))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0924))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0925))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0926))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0927))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0928))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0929))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0930))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0931))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0932))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0933))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0934))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0935))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0936))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0937))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0938))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0939))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0940))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0941))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0942))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0943))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0944))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0945))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0946))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0947))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0948))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0949))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0950))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0951))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0952))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0953))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0954))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0955))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0956))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0957))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0958))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0959))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0960))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0961))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0962))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0963))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0964))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0965))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0966))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0967))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0968))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0969))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0970))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0971))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0972))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0973))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0974))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0975))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0976))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0977))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0978))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0979))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0980))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0981))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0982))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0983))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0984))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0985))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0986))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0987))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0988))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0989))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0990))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0991))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0992))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0993))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0994))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0995))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0996))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0997))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0998))
+                {
+                    return true;
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0999))
+                {
+                    return true;
+                }
+                throw new Exception($"Invalid type: {type}");
+            }
+
+            private partial bool CheckGetOrAddTo(VolumeComponentArchetype archetype, Type type)
+            {
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0000))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0000, GeneratedExtensions.VolumeArchetypeExtensionTest0000.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0001))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0001, GeneratedExtensions.VolumeArchetypeExtensionTest0001.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0002))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0002, GeneratedExtensions.VolumeArchetypeExtensionTest0002.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0003))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0003, GeneratedExtensions.VolumeArchetypeExtensionTest0003.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0004))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0004, GeneratedExtensions.VolumeArchetypeExtensionTest0004.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0005))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0005, GeneratedExtensions.VolumeArchetypeExtensionTest0005.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0006))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0006, GeneratedExtensions.VolumeArchetypeExtensionTest0006.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0007))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0007, GeneratedExtensions.VolumeArchetypeExtensionTest0007.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0008))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0008, GeneratedExtensions.VolumeArchetypeExtensionTest0008.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0009))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0009, GeneratedExtensions.VolumeArchetypeExtensionTest0009.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0010))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0010, GeneratedExtensions.VolumeArchetypeExtensionTest0010.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0011))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0011, GeneratedExtensions.VolumeArchetypeExtensionTest0011.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0012))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0012, GeneratedExtensions.VolumeArchetypeExtensionTest0012.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0013))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0013, GeneratedExtensions.VolumeArchetypeExtensionTest0013.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0014))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0014, GeneratedExtensions.VolumeArchetypeExtensionTest0014.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0015))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0015, GeneratedExtensions.VolumeArchetypeExtensionTest0015.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0016))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0016, GeneratedExtensions.VolumeArchetypeExtensionTest0016.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0017))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0017, GeneratedExtensions.VolumeArchetypeExtensionTest0017.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0018))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0018, GeneratedExtensions.VolumeArchetypeExtensionTest0018.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0019))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0019, GeneratedExtensions.VolumeArchetypeExtensionTest0019.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0020))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0020, GeneratedExtensions.VolumeArchetypeExtensionTest0020.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0021))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0021, GeneratedExtensions.VolumeArchetypeExtensionTest0021.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0022))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0022, GeneratedExtensions.VolumeArchetypeExtensionTest0022.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0023))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0023, GeneratedExtensions.VolumeArchetypeExtensionTest0023.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0024))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0024, GeneratedExtensions.VolumeArchetypeExtensionTest0024.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0025))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0025, GeneratedExtensions.VolumeArchetypeExtensionTest0025.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0026))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0026, GeneratedExtensions.VolumeArchetypeExtensionTest0026.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0027))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0027, GeneratedExtensions.VolumeArchetypeExtensionTest0027.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0028))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0028, GeneratedExtensions.VolumeArchetypeExtensionTest0028.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0029))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0029, GeneratedExtensions.VolumeArchetypeExtensionTest0029.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0030))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0030, GeneratedExtensions.VolumeArchetypeExtensionTest0030.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0031))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0031, GeneratedExtensions.VolumeArchetypeExtensionTest0031.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0032))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0032, GeneratedExtensions.VolumeArchetypeExtensionTest0032.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0033))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0033, GeneratedExtensions.VolumeArchetypeExtensionTest0033.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0034))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0034, GeneratedExtensions.VolumeArchetypeExtensionTest0034.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0035))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0035, GeneratedExtensions.VolumeArchetypeExtensionTest0035.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0036))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0036, GeneratedExtensions.VolumeArchetypeExtensionTest0036.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0037))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0037, GeneratedExtensions.VolumeArchetypeExtensionTest0037.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0038))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0038, GeneratedExtensions.VolumeArchetypeExtensionTest0038.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0039))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0039, GeneratedExtensions.VolumeArchetypeExtensionTest0039.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0040))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0040, GeneratedExtensions.VolumeArchetypeExtensionTest0040.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0041))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0041, GeneratedExtensions.VolumeArchetypeExtensionTest0041.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0042))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0042, GeneratedExtensions.VolumeArchetypeExtensionTest0042.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0043))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0043, GeneratedExtensions.VolumeArchetypeExtensionTest0043.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0044))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0044, GeneratedExtensions.VolumeArchetypeExtensionTest0044.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0045))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0045, GeneratedExtensions.VolumeArchetypeExtensionTest0045.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0046))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0046, GeneratedExtensions.VolumeArchetypeExtensionTest0046.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0047))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0047, GeneratedExtensions.VolumeArchetypeExtensionTest0047.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0048))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0048, GeneratedExtensions.VolumeArchetypeExtensionTest0048.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0049))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0049, GeneratedExtensions.VolumeArchetypeExtensionTest0049.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0050))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0050, GeneratedExtensions.VolumeArchetypeExtensionTest0050.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0051))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0051, GeneratedExtensions.VolumeArchetypeExtensionTest0051.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0052))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0052, GeneratedExtensions.VolumeArchetypeExtensionTest0052.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0053))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0053, GeneratedExtensions.VolumeArchetypeExtensionTest0053.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0054))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0054, GeneratedExtensions.VolumeArchetypeExtensionTest0054.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0055))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0055, GeneratedExtensions.VolumeArchetypeExtensionTest0055.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0056))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0056, GeneratedExtensions.VolumeArchetypeExtensionTest0056.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0057))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0057, GeneratedExtensions.VolumeArchetypeExtensionTest0057.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0058))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0058, GeneratedExtensions.VolumeArchetypeExtensionTest0058.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0059))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0059, GeneratedExtensions.VolumeArchetypeExtensionTest0059.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0060))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0060, GeneratedExtensions.VolumeArchetypeExtensionTest0060.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0061))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0061, GeneratedExtensions.VolumeArchetypeExtensionTest0061.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0062))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0062, GeneratedExtensions.VolumeArchetypeExtensionTest0062.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0063))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0063, GeneratedExtensions.VolumeArchetypeExtensionTest0063.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0064))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0064, GeneratedExtensions.VolumeArchetypeExtensionTest0064.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0065))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0065, GeneratedExtensions.VolumeArchetypeExtensionTest0065.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0066))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0066, GeneratedExtensions.VolumeArchetypeExtensionTest0066.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0067))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0067, GeneratedExtensions.VolumeArchetypeExtensionTest0067.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0068))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0068, GeneratedExtensions.VolumeArchetypeExtensionTest0068.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0069))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0069, GeneratedExtensions.VolumeArchetypeExtensionTest0069.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0070))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0070, GeneratedExtensions.VolumeArchetypeExtensionTest0070.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0071))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0071, GeneratedExtensions.VolumeArchetypeExtensionTest0071.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0072))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0072, GeneratedExtensions.VolumeArchetypeExtensionTest0072.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0073))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0073, GeneratedExtensions.VolumeArchetypeExtensionTest0073.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0074))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0074, GeneratedExtensions.VolumeArchetypeExtensionTest0074.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0075))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0075, GeneratedExtensions.VolumeArchetypeExtensionTest0075.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0076))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0076, GeneratedExtensions.VolumeArchetypeExtensionTest0076.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0077))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0077, GeneratedExtensions.VolumeArchetypeExtensionTest0077.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0078))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0078, GeneratedExtensions.VolumeArchetypeExtensionTest0078.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0079))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0079, GeneratedExtensions.VolumeArchetypeExtensionTest0079.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0080))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0080, GeneratedExtensions.VolumeArchetypeExtensionTest0080.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0081))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0081, GeneratedExtensions.VolumeArchetypeExtensionTest0081.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0082))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0082, GeneratedExtensions.VolumeArchetypeExtensionTest0082.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0083))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0083, GeneratedExtensions.VolumeArchetypeExtensionTest0083.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0084))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0084, GeneratedExtensions.VolumeArchetypeExtensionTest0084.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0085))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0085, GeneratedExtensions.VolumeArchetypeExtensionTest0085.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0086))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0086, GeneratedExtensions.VolumeArchetypeExtensionTest0086.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0087))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0087, GeneratedExtensions.VolumeArchetypeExtensionTest0087.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0088))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0088, GeneratedExtensions.VolumeArchetypeExtensionTest0088.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0089))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0089, GeneratedExtensions.VolumeArchetypeExtensionTest0089.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0090))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0090, GeneratedExtensions.VolumeArchetypeExtensionTest0090.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0091))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0091, GeneratedExtensions.VolumeArchetypeExtensionTest0091.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0092))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0092, GeneratedExtensions.VolumeArchetypeExtensionTest0092.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0093))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0093, GeneratedExtensions.VolumeArchetypeExtensionTest0093.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0094))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0094, GeneratedExtensions.VolumeArchetypeExtensionTest0094.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0095))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0095, GeneratedExtensions.VolumeArchetypeExtensionTest0095.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0096))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0096, GeneratedExtensions.VolumeArchetypeExtensionTest0096.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0097))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0097, GeneratedExtensions.VolumeArchetypeExtensionTest0097.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0098))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0098, GeneratedExtensions.VolumeArchetypeExtensionTest0098.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0099))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0099, GeneratedExtensions.VolumeArchetypeExtensionTest0099.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0100))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0100, GeneratedExtensions.VolumeArchetypeExtensionTest0100.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0101))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0101, GeneratedExtensions.VolumeArchetypeExtensionTest0101.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0102))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0102, GeneratedExtensions.VolumeArchetypeExtensionTest0102.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0103))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0103, GeneratedExtensions.VolumeArchetypeExtensionTest0103.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0104))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0104, GeneratedExtensions.VolumeArchetypeExtensionTest0104.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0105))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0105, GeneratedExtensions.VolumeArchetypeExtensionTest0105.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0106))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0106, GeneratedExtensions.VolumeArchetypeExtensionTest0106.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0107))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0107, GeneratedExtensions.VolumeArchetypeExtensionTest0107.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0108))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0108, GeneratedExtensions.VolumeArchetypeExtensionTest0108.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0109))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0109, GeneratedExtensions.VolumeArchetypeExtensionTest0109.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0110))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0110, GeneratedExtensions.VolumeArchetypeExtensionTest0110.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0111))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0111, GeneratedExtensions.VolumeArchetypeExtensionTest0111.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0112))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0112, GeneratedExtensions.VolumeArchetypeExtensionTest0112.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0113))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0113, GeneratedExtensions.VolumeArchetypeExtensionTest0113.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0114))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0114, GeneratedExtensions.VolumeArchetypeExtensionTest0114.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0115))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0115, GeneratedExtensions.VolumeArchetypeExtensionTest0115.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0116))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0116, GeneratedExtensions.VolumeArchetypeExtensionTest0116.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0117))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0117, GeneratedExtensions.VolumeArchetypeExtensionTest0117.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0118))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0118, GeneratedExtensions.VolumeArchetypeExtensionTest0118.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0119))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0119, GeneratedExtensions.VolumeArchetypeExtensionTest0119.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0120))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0120, GeneratedExtensions.VolumeArchetypeExtensionTest0120.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0121))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0121, GeneratedExtensions.VolumeArchetypeExtensionTest0121.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0122))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0122, GeneratedExtensions.VolumeArchetypeExtensionTest0122.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0123))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0123, GeneratedExtensions.VolumeArchetypeExtensionTest0123.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0124))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0124, GeneratedExtensions.VolumeArchetypeExtensionTest0124.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0125))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0125, GeneratedExtensions.VolumeArchetypeExtensionTest0125.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0126))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0126, GeneratedExtensions.VolumeArchetypeExtensionTest0126.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0127))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0127, GeneratedExtensions.VolumeArchetypeExtensionTest0127.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0128))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0128, GeneratedExtensions.VolumeArchetypeExtensionTest0128.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0129))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0129, GeneratedExtensions.VolumeArchetypeExtensionTest0129.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0130))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0130, GeneratedExtensions.VolumeArchetypeExtensionTest0130.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0131))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0131, GeneratedExtensions.VolumeArchetypeExtensionTest0131.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0132))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0132, GeneratedExtensions.VolumeArchetypeExtensionTest0132.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0133))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0133, GeneratedExtensions.VolumeArchetypeExtensionTest0133.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0134))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0134, GeneratedExtensions.VolumeArchetypeExtensionTest0134.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0135))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0135, GeneratedExtensions.VolumeArchetypeExtensionTest0135.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0136))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0136, GeneratedExtensions.VolumeArchetypeExtensionTest0136.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0137))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0137, GeneratedExtensions.VolumeArchetypeExtensionTest0137.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0138))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0138, GeneratedExtensions.VolumeArchetypeExtensionTest0138.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0139))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0139, GeneratedExtensions.VolumeArchetypeExtensionTest0139.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0140))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0140, GeneratedExtensions.VolumeArchetypeExtensionTest0140.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0141))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0141, GeneratedExtensions.VolumeArchetypeExtensionTest0141.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0142))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0142, GeneratedExtensions.VolumeArchetypeExtensionTest0142.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0143))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0143, GeneratedExtensions.VolumeArchetypeExtensionTest0143.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0144))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0144, GeneratedExtensions.VolumeArchetypeExtensionTest0144.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0145))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0145, GeneratedExtensions.VolumeArchetypeExtensionTest0145.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0146))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0146, GeneratedExtensions.VolumeArchetypeExtensionTest0146.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0147))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0147, GeneratedExtensions.VolumeArchetypeExtensionTest0147.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0148))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0148, GeneratedExtensions.VolumeArchetypeExtensionTest0148.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0149))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0149, GeneratedExtensions.VolumeArchetypeExtensionTest0149.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0150))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0150, GeneratedExtensions.VolumeArchetypeExtensionTest0150.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0151))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0151, GeneratedExtensions.VolumeArchetypeExtensionTest0151.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0152))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0152, GeneratedExtensions.VolumeArchetypeExtensionTest0152.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0153))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0153, GeneratedExtensions.VolumeArchetypeExtensionTest0153.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0154))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0154, GeneratedExtensions.VolumeArchetypeExtensionTest0154.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0155))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0155, GeneratedExtensions.VolumeArchetypeExtensionTest0155.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0156))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0156, GeneratedExtensions.VolumeArchetypeExtensionTest0156.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0157))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0157, GeneratedExtensions.VolumeArchetypeExtensionTest0157.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0158))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0158, GeneratedExtensions.VolumeArchetypeExtensionTest0158.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0159))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0159, GeneratedExtensions.VolumeArchetypeExtensionTest0159.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0160))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0160, GeneratedExtensions.VolumeArchetypeExtensionTest0160.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0161))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0161, GeneratedExtensions.VolumeArchetypeExtensionTest0161.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0162))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0162, GeneratedExtensions.VolumeArchetypeExtensionTest0162.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0163))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0163, GeneratedExtensions.VolumeArchetypeExtensionTest0163.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0164))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0164, GeneratedExtensions.VolumeArchetypeExtensionTest0164.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0165))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0165, GeneratedExtensions.VolumeArchetypeExtensionTest0165.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0166))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0166, GeneratedExtensions.VolumeArchetypeExtensionTest0166.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0167))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0167, GeneratedExtensions.VolumeArchetypeExtensionTest0167.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0168))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0168, GeneratedExtensions.VolumeArchetypeExtensionTest0168.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0169))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0169, GeneratedExtensions.VolumeArchetypeExtensionTest0169.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0170))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0170, GeneratedExtensions.VolumeArchetypeExtensionTest0170.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0171))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0171, GeneratedExtensions.VolumeArchetypeExtensionTest0171.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0172))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0172, GeneratedExtensions.VolumeArchetypeExtensionTest0172.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0173))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0173, GeneratedExtensions.VolumeArchetypeExtensionTest0173.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0174))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0174, GeneratedExtensions.VolumeArchetypeExtensionTest0174.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0175))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0175, GeneratedExtensions.VolumeArchetypeExtensionTest0175.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0176))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0176, GeneratedExtensions.VolumeArchetypeExtensionTest0176.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0177))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0177, GeneratedExtensions.VolumeArchetypeExtensionTest0177.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0178))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0178, GeneratedExtensions.VolumeArchetypeExtensionTest0178.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0179))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0179, GeneratedExtensions.VolumeArchetypeExtensionTest0179.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0180))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0180, GeneratedExtensions.VolumeArchetypeExtensionTest0180.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0181))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0181, GeneratedExtensions.VolumeArchetypeExtensionTest0181.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0182))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0182, GeneratedExtensions.VolumeArchetypeExtensionTest0182.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0183))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0183, GeneratedExtensions.VolumeArchetypeExtensionTest0183.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0184))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0184, GeneratedExtensions.VolumeArchetypeExtensionTest0184.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0185))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0185, GeneratedExtensions.VolumeArchetypeExtensionTest0185.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0186))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0186, GeneratedExtensions.VolumeArchetypeExtensionTest0186.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0187))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0187, GeneratedExtensions.VolumeArchetypeExtensionTest0187.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0188))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0188, GeneratedExtensions.VolumeArchetypeExtensionTest0188.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0189))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0189, GeneratedExtensions.VolumeArchetypeExtensionTest0189.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0190))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0190, GeneratedExtensions.VolumeArchetypeExtensionTest0190.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0191))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0191, GeneratedExtensions.VolumeArchetypeExtensionTest0191.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0192))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0192, GeneratedExtensions.VolumeArchetypeExtensionTest0192.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0193))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0193, GeneratedExtensions.VolumeArchetypeExtensionTest0193.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0194))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0194, GeneratedExtensions.VolumeArchetypeExtensionTest0194.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0195))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0195, GeneratedExtensions.VolumeArchetypeExtensionTest0195.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0196))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0196, GeneratedExtensions.VolumeArchetypeExtensionTest0196.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0197))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0197, GeneratedExtensions.VolumeArchetypeExtensionTest0197.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0198))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0198, GeneratedExtensions.VolumeArchetypeExtensionTest0198.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0199))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0199, GeneratedExtensions.VolumeArchetypeExtensionTest0199.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0200))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0200, GeneratedExtensions.VolumeArchetypeExtensionTest0200.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0201))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0201, GeneratedExtensions.VolumeArchetypeExtensionTest0201.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0202))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0202, GeneratedExtensions.VolumeArchetypeExtensionTest0202.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0203))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0203, GeneratedExtensions.VolumeArchetypeExtensionTest0203.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0204))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0204, GeneratedExtensions.VolumeArchetypeExtensionTest0204.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0205))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0205, GeneratedExtensions.VolumeArchetypeExtensionTest0205.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0206))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0206, GeneratedExtensions.VolumeArchetypeExtensionTest0206.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0207))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0207, GeneratedExtensions.VolumeArchetypeExtensionTest0207.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0208))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0208, GeneratedExtensions.VolumeArchetypeExtensionTest0208.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0209))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0209, GeneratedExtensions.VolumeArchetypeExtensionTest0209.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0210))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0210, GeneratedExtensions.VolumeArchetypeExtensionTest0210.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0211))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0211, GeneratedExtensions.VolumeArchetypeExtensionTest0211.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0212))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0212, GeneratedExtensions.VolumeArchetypeExtensionTest0212.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0213))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0213, GeneratedExtensions.VolumeArchetypeExtensionTest0213.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0214))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0214, GeneratedExtensions.VolumeArchetypeExtensionTest0214.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0215))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0215, GeneratedExtensions.VolumeArchetypeExtensionTest0215.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0216))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0216, GeneratedExtensions.VolumeArchetypeExtensionTest0216.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0217))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0217, GeneratedExtensions.VolumeArchetypeExtensionTest0217.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0218))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0218, GeneratedExtensions.VolumeArchetypeExtensionTest0218.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0219))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0219, GeneratedExtensions.VolumeArchetypeExtensionTest0219.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0220))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0220, GeneratedExtensions.VolumeArchetypeExtensionTest0220.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0221))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0221, GeneratedExtensions.VolumeArchetypeExtensionTest0221.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0222))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0222, GeneratedExtensions.VolumeArchetypeExtensionTest0222.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0223))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0223, GeneratedExtensions.VolumeArchetypeExtensionTest0223.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0224))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0224, GeneratedExtensions.VolumeArchetypeExtensionTest0224.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0225))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0225, GeneratedExtensions.VolumeArchetypeExtensionTest0225.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0226))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0226, GeneratedExtensions.VolumeArchetypeExtensionTest0226.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0227))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0227, GeneratedExtensions.VolumeArchetypeExtensionTest0227.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0228))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0228, GeneratedExtensions.VolumeArchetypeExtensionTest0228.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0229))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0229, GeneratedExtensions.VolumeArchetypeExtensionTest0229.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0230))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0230, GeneratedExtensions.VolumeArchetypeExtensionTest0230.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0231))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0231, GeneratedExtensions.VolumeArchetypeExtensionTest0231.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0232))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0232, GeneratedExtensions.VolumeArchetypeExtensionTest0232.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0233))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0233, GeneratedExtensions.VolumeArchetypeExtensionTest0233.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0234))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0234, GeneratedExtensions.VolumeArchetypeExtensionTest0234.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0235))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0235, GeneratedExtensions.VolumeArchetypeExtensionTest0235.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0236))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0236, GeneratedExtensions.VolumeArchetypeExtensionTest0236.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0237))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0237, GeneratedExtensions.VolumeArchetypeExtensionTest0237.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0238))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0238, GeneratedExtensions.VolumeArchetypeExtensionTest0238.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0239))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0239, GeneratedExtensions.VolumeArchetypeExtensionTest0239.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0240))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0240, GeneratedExtensions.VolumeArchetypeExtensionTest0240.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0241))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0241, GeneratedExtensions.VolumeArchetypeExtensionTest0241.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0242))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0242, GeneratedExtensions.VolumeArchetypeExtensionTest0242.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0243))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0243, GeneratedExtensions.VolumeArchetypeExtensionTest0243.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0244))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0244, GeneratedExtensions.VolumeArchetypeExtensionTest0244.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0245))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0245, GeneratedExtensions.VolumeArchetypeExtensionTest0245.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0246))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0246, GeneratedExtensions.VolumeArchetypeExtensionTest0246.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0247))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0247, GeneratedExtensions.VolumeArchetypeExtensionTest0247.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0248))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0248, GeneratedExtensions.VolumeArchetypeExtensionTest0248.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0249))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0249, GeneratedExtensions.VolumeArchetypeExtensionTest0249.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0250))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0250, GeneratedExtensions.VolumeArchetypeExtensionTest0250.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0251))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0251, GeneratedExtensions.VolumeArchetypeExtensionTest0251.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0252))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0252, GeneratedExtensions.VolumeArchetypeExtensionTest0252.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0253))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0253, GeneratedExtensions.VolumeArchetypeExtensionTest0253.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0254))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0254, GeneratedExtensions.VolumeArchetypeExtensionTest0254.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0255))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0255, GeneratedExtensions.VolumeArchetypeExtensionTest0255.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0256))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0256, GeneratedExtensions.VolumeArchetypeExtensionTest0256.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0257))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0257, GeneratedExtensions.VolumeArchetypeExtensionTest0257.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0258))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0258, GeneratedExtensions.VolumeArchetypeExtensionTest0258.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0259))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0259, GeneratedExtensions.VolumeArchetypeExtensionTest0259.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0260))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0260, GeneratedExtensions.VolumeArchetypeExtensionTest0260.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0261))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0261, GeneratedExtensions.VolumeArchetypeExtensionTest0261.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0262))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0262, GeneratedExtensions.VolumeArchetypeExtensionTest0262.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0263))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0263, GeneratedExtensions.VolumeArchetypeExtensionTest0263.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0264))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0264, GeneratedExtensions.VolumeArchetypeExtensionTest0264.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0265))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0265, GeneratedExtensions.VolumeArchetypeExtensionTest0265.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0266))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0266, GeneratedExtensions.VolumeArchetypeExtensionTest0266.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0267))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0267, GeneratedExtensions.VolumeArchetypeExtensionTest0267.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0268))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0268, GeneratedExtensions.VolumeArchetypeExtensionTest0268.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0269))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0269, GeneratedExtensions.VolumeArchetypeExtensionTest0269.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0270))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0270, GeneratedExtensions.VolumeArchetypeExtensionTest0270.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0271))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0271, GeneratedExtensions.VolumeArchetypeExtensionTest0271.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0272))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0272, GeneratedExtensions.VolumeArchetypeExtensionTest0272.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0273))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0273, GeneratedExtensions.VolumeArchetypeExtensionTest0273.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0274))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0274, GeneratedExtensions.VolumeArchetypeExtensionTest0274.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0275))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0275, GeneratedExtensions.VolumeArchetypeExtensionTest0275.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0276))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0276, GeneratedExtensions.VolumeArchetypeExtensionTest0276.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0277))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0277, GeneratedExtensions.VolumeArchetypeExtensionTest0277.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0278))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0278, GeneratedExtensions.VolumeArchetypeExtensionTest0278.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0279))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0279, GeneratedExtensions.VolumeArchetypeExtensionTest0279.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0280))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0280, GeneratedExtensions.VolumeArchetypeExtensionTest0280.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0281))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0281, GeneratedExtensions.VolumeArchetypeExtensionTest0281.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0282))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0282, GeneratedExtensions.VolumeArchetypeExtensionTest0282.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0283))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0283, GeneratedExtensions.VolumeArchetypeExtensionTest0283.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0284))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0284, GeneratedExtensions.VolumeArchetypeExtensionTest0284.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0285))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0285, GeneratedExtensions.VolumeArchetypeExtensionTest0285.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0286))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0286, GeneratedExtensions.VolumeArchetypeExtensionTest0286.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0287))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0287, GeneratedExtensions.VolumeArchetypeExtensionTest0287.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0288))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0288, GeneratedExtensions.VolumeArchetypeExtensionTest0288.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0289))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0289, GeneratedExtensions.VolumeArchetypeExtensionTest0289.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0290))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0290, GeneratedExtensions.VolumeArchetypeExtensionTest0290.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0291))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0291, GeneratedExtensions.VolumeArchetypeExtensionTest0291.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0292))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0292, GeneratedExtensions.VolumeArchetypeExtensionTest0292.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0293))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0293, GeneratedExtensions.VolumeArchetypeExtensionTest0293.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0294))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0294, GeneratedExtensions.VolumeArchetypeExtensionTest0294.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0295))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0295, GeneratedExtensions.VolumeArchetypeExtensionTest0295.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0296))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0296, GeneratedExtensions.VolumeArchetypeExtensionTest0296.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0297))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0297, GeneratedExtensions.VolumeArchetypeExtensionTest0297.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0298))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0298, GeneratedExtensions.VolumeArchetypeExtensionTest0298.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0299))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0299, GeneratedExtensions.VolumeArchetypeExtensionTest0299.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0300))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0300, GeneratedExtensions.VolumeArchetypeExtensionTest0300.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0301))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0301, GeneratedExtensions.VolumeArchetypeExtensionTest0301.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0302))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0302, GeneratedExtensions.VolumeArchetypeExtensionTest0302.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0303))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0303, GeneratedExtensions.VolumeArchetypeExtensionTest0303.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0304))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0304, GeneratedExtensions.VolumeArchetypeExtensionTest0304.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0305))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0305, GeneratedExtensions.VolumeArchetypeExtensionTest0305.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0306))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0306, GeneratedExtensions.VolumeArchetypeExtensionTest0306.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0307))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0307, GeneratedExtensions.VolumeArchetypeExtensionTest0307.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0308))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0308, GeneratedExtensions.VolumeArchetypeExtensionTest0308.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0309))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0309, GeneratedExtensions.VolumeArchetypeExtensionTest0309.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0310))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0310, GeneratedExtensions.VolumeArchetypeExtensionTest0310.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0311))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0311, GeneratedExtensions.VolumeArchetypeExtensionTest0311.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0312))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0312, GeneratedExtensions.VolumeArchetypeExtensionTest0312.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0313))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0313, GeneratedExtensions.VolumeArchetypeExtensionTest0313.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0314))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0314, GeneratedExtensions.VolumeArchetypeExtensionTest0314.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0315))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0315, GeneratedExtensions.VolumeArchetypeExtensionTest0315.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0316))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0316, GeneratedExtensions.VolumeArchetypeExtensionTest0316.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0317))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0317, GeneratedExtensions.VolumeArchetypeExtensionTest0317.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0318))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0318, GeneratedExtensions.VolumeArchetypeExtensionTest0318.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0319))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0319, GeneratedExtensions.VolumeArchetypeExtensionTest0319.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0320))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0320, GeneratedExtensions.VolumeArchetypeExtensionTest0320.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0321))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0321, GeneratedExtensions.VolumeArchetypeExtensionTest0321.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0322))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0322, GeneratedExtensions.VolumeArchetypeExtensionTest0322.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0323))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0323, GeneratedExtensions.VolumeArchetypeExtensionTest0323.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0324))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0324, GeneratedExtensions.VolumeArchetypeExtensionTest0324.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0325))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0325, GeneratedExtensions.VolumeArchetypeExtensionTest0325.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0326))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0326, GeneratedExtensions.VolumeArchetypeExtensionTest0326.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0327))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0327, GeneratedExtensions.VolumeArchetypeExtensionTest0327.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0328))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0328, GeneratedExtensions.VolumeArchetypeExtensionTest0328.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0329))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0329, GeneratedExtensions.VolumeArchetypeExtensionTest0329.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0330))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0330, GeneratedExtensions.VolumeArchetypeExtensionTest0330.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0331))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0331, GeneratedExtensions.VolumeArchetypeExtensionTest0331.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0332))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0332, GeneratedExtensions.VolumeArchetypeExtensionTest0332.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0333))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0333, GeneratedExtensions.VolumeArchetypeExtensionTest0333.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0334))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0334, GeneratedExtensions.VolumeArchetypeExtensionTest0334.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0335))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0335, GeneratedExtensions.VolumeArchetypeExtensionTest0335.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0336))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0336, GeneratedExtensions.VolumeArchetypeExtensionTest0336.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0337))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0337, GeneratedExtensions.VolumeArchetypeExtensionTest0337.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0338))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0338, GeneratedExtensions.VolumeArchetypeExtensionTest0338.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0339))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0339, GeneratedExtensions.VolumeArchetypeExtensionTest0339.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0340))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0340, GeneratedExtensions.VolumeArchetypeExtensionTest0340.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0341))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0341, GeneratedExtensions.VolumeArchetypeExtensionTest0341.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0342))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0342, GeneratedExtensions.VolumeArchetypeExtensionTest0342.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0343))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0343, GeneratedExtensions.VolumeArchetypeExtensionTest0343.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0344))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0344, GeneratedExtensions.VolumeArchetypeExtensionTest0344.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0345))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0345, GeneratedExtensions.VolumeArchetypeExtensionTest0345.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0346))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0346, GeneratedExtensions.VolumeArchetypeExtensionTest0346.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0347))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0347, GeneratedExtensions.VolumeArchetypeExtensionTest0347.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0348))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0348, GeneratedExtensions.VolumeArchetypeExtensionTest0348.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0349))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0349, GeneratedExtensions.VolumeArchetypeExtensionTest0349.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0350))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0350, GeneratedExtensions.VolumeArchetypeExtensionTest0350.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0351))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0351, GeneratedExtensions.VolumeArchetypeExtensionTest0351.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0352))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0352, GeneratedExtensions.VolumeArchetypeExtensionTest0352.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0353))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0353, GeneratedExtensions.VolumeArchetypeExtensionTest0353.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0354))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0354, GeneratedExtensions.VolumeArchetypeExtensionTest0354.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0355))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0355, GeneratedExtensions.VolumeArchetypeExtensionTest0355.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0356))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0356, GeneratedExtensions.VolumeArchetypeExtensionTest0356.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0357))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0357, GeneratedExtensions.VolumeArchetypeExtensionTest0357.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0358))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0358, GeneratedExtensions.VolumeArchetypeExtensionTest0358.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0359))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0359, GeneratedExtensions.VolumeArchetypeExtensionTest0359.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0360))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0360, GeneratedExtensions.VolumeArchetypeExtensionTest0360.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0361))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0361, GeneratedExtensions.VolumeArchetypeExtensionTest0361.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0362))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0362, GeneratedExtensions.VolumeArchetypeExtensionTest0362.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0363))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0363, GeneratedExtensions.VolumeArchetypeExtensionTest0363.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0364))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0364, GeneratedExtensions.VolumeArchetypeExtensionTest0364.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0365))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0365, GeneratedExtensions.VolumeArchetypeExtensionTest0365.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0366))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0366, GeneratedExtensions.VolumeArchetypeExtensionTest0366.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0367))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0367, GeneratedExtensions.VolumeArchetypeExtensionTest0367.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0368))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0368, GeneratedExtensions.VolumeArchetypeExtensionTest0368.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0369))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0369, GeneratedExtensions.VolumeArchetypeExtensionTest0369.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0370))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0370, GeneratedExtensions.VolumeArchetypeExtensionTest0370.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0371))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0371, GeneratedExtensions.VolumeArchetypeExtensionTest0371.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0372))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0372, GeneratedExtensions.VolumeArchetypeExtensionTest0372.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0373))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0373, GeneratedExtensions.VolumeArchetypeExtensionTest0373.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0374))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0374, GeneratedExtensions.VolumeArchetypeExtensionTest0374.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0375))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0375, GeneratedExtensions.VolumeArchetypeExtensionTest0375.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0376))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0376, GeneratedExtensions.VolumeArchetypeExtensionTest0376.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0377))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0377, GeneratedExtensions.VolumeArchetypeExtensionTest0377.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0378))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0378, GeneratedExtensions.VolumeArchetypeExtensionTest0378.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0379))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0379, GeneratedExtensions.VolumeArchetypeExtensionTest0379.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0380))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0380, GeneratedExtensions.VolumeArchetypeExtensionTest0380.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0381))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0381, GeneratedExtensions.VolumeArchetypeExtensionTest0381.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0382))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0382, GeneratedExtensions.VolumeArchetypeExtensionTest0382.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0383))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0383, GeneratedExtensions.VolumeArchetypeExtensionTest0383.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0384))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0384, GeneratedExtensions.VolumeArchetypeExtensionTest0384.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0385))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0385, GeneratedExtensions.VolumeArchetypeExtensionTest0385.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0386))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0386, GeneratedExtensions.VolumeArchetypeExtensionTest0386.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0387))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0387, GeneratedExtensions.VolumeArchetypeExtensionTest0387.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0388))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0388, GeneratedExtensions.VolumeArchetypeExtensionTest0388.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0389))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0389, GeneratedExtensions.VolumeArchetypeExtensionTest0389.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0390))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0390, GeneratedExtensions.VolumeArchetypeExtensionTest0390.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0391))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0391, GeneratedExtensions.VolumeArchetypeExtensionTest0391.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0392))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0392, GeneratedExtensions.VolumeArchetypeExtensionTest0392.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0393))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0393, GeneratedExtensions.VolumeArchetypeExtensionTest0393.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0394))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0394, GeneratedExtensions.VolumeArchetypeExtensionTest0394.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0395))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0395, GeneratedExtensions.VolumeArchetypeExtensionTest0395.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0396))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0396, GeneratedExtensions.VolumeArchetypeExtensionTest0396.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0397))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0397, GeneratedExtensions.VolumeArchetypeExtensionTest0397.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0398))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0398, GeneratedExtensions.VolumeArchetypeExtensionTest0398.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0399))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0399, GeneratedExtensions.VolumeArchetypeExtensionTest0399.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0400))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0400, GeneratedExtensions.VolumeArchetypeExtensionTest0400.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0401))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0401, GeneratedExtensions.VolumeArchetypeExtensionTest0401.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0402))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0402, GeneratedExtensions.VolumeArchetypeExtensionTest0402.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0403))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0403, GeneratedExtensions.VolumeArchetypeExtensionTest0403.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0404))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0404, GeneratedExtensions.VolumeArchetypeExtensionTest0404.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0405))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0405, GeneratedExtensions.VolumeArchetypeExtensionTest0405.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0406))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0406, GeneratedExtensions.VolumeArchetypeExtensionTest0406.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0407))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0407, GeneratedExtensions.VolumeArchetypeExtensionTest0407.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0408))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0408, GeneratedExtensions.VolumeArchetypeExtensionTest0408.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0409))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0409, GeneratedExtensions.VolumeArchetypeExtensionTest0409.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0410))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0410, GeneratedExtensions.VolumeArchetypeExtensionTest0410.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0411))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0411, GeneratedExtensions.VolumeArchetypeExtensionTest0411.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0412))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0412, GeneratedExtensions.VolumeArchetypeExtensionTest0412.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0413))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0413, GeneratedExtensions.VolumeArchetypeExtensionTest0413.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0414))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0414, GeneratedExtensions.VolumeArchetypeExtensionTest0414.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0415))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0415, GeneratedExtensions.VolumeArchetypeExtensionTest0415.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0416))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0416, GeneratedExtensions.VolumeArchetypeExtensionTest0416.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0417))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0417, GeneratedExtensions.VolumeArchetypeExtensionTest0417.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0418))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0418, GeneratedExtensions.VolumeArchetypeExtensionTest0418.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0419))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0419, GeneratedExtensions.VolumeArchetypeExtensionTest0419.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0420))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0420, GeneratedExtensions.VolumeArchetypeExtensionTest0420.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0421))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0421, GeneratedExtensions.VolumeArchetypeExtensionTest0421.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0422))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0422, GeneratedExtensions.VolumeArchetypeExtensionTest0422.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0423))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0423, GeneratedExtensions.VolumeArchetypeExtensionTest0423.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0424))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0424, GeneratedExtensions.VolumeArchetypeExtensionTest0424.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0425))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0425, GeneratedExtensions.VolumeArchetypeExtensionTest0425.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0426))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0426, GeneratedExtensions.VolumeArchetypeExtensionTest0426.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0427))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0427, GeneratedExtensions.VolumeArchetypeExtensionTest0427.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0428))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0428, GeneratedExtensions.VolumeArchetypeExtensionTest0428.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0429))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0429, GeneratedExtensions.VolumeArchetypeExtensionTest0429.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0430))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0430, GeneratedExtensions.VolumeArchetypeExtensionTest0430.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0431))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0431, GeneratedExtensions.VolumeArchetypeExtensionTest0431.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0432))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0432, GeneratedExtensions.VolumeArchetypeExtensionTest0432.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0433))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0433, GeneratedExtensions.VolumeArchetypeExtensionTest0433.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0434))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0434, GeneratedExtensions.VolumeArchetypeExtensionTest0434.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0435))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0435, GeneratedExtensions.VolumeArchetypeExtensionTest0435.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0436))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0436, GeneratedExtensions.VolumeArchetypeExtensionTest0436.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0437))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0437, GeneratedExtensions.VolumeArchetypeExtensionTest0437.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0438))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0438, GeneratedExtensions.VolumeArchetypeExtensionTest0438.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0439))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0439, GeneratedExtensions.VolumeArchetypeExtensionTest0439.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0440))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0440, GeneratedExtensions.VolumeArchetypeExtensionTest0440.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0441))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0441, GeneratedExtensions.VolumeArchetypeExtensionTest0441.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0442))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0442, GeneratedExtensions.VolumeArchetypeExtensionTest0442.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0443))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0443, GeneratedExtensions.VolumeArchetypeExtensionTest0443.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0444))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0444, GeneratedExtensions.VolumeArchetypeExtensionTest0444.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0445))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0445, GeneratedExtensions.VolumeArchetypeExtensionTest0445.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0446))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0446, GeneratedExtensions.VolumeArchetypeExtensionTest0446.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0447))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0447, GeneratedExtensions.VolumeArchetypeExtensionTest0447.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0448))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0448, GeneratedExtensions.VolumeArchetypeExtensionTest0448.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0449))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0449, GeneratedExtensions.VolumeArchetypeExtensionTest0449.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0450))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0450, GeneratedExtensions.VolumeArchetypeExtensionTest0450.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0451))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0451, GeneratedExtensions.VolumeArchetypeExtensionTest0451.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0452))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0452, GeneratedExtensions.VolumeArchetypeExtensionTest0452.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0453))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0453, GeneratedExtensions.VolumeArchetypeExtensionTest0453.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0454))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0454, GeneratedExtensions.VolumeArchetypeExtensionTest0454.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0455))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0455, GeneratedExtensions.VolumeArchetypeExtensionTest0455.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0456))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0456, GeneratedExtensions.VolumeArchetypeExtensionTest0456.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0457))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0457, GeneratedExtensions.VolumeArchetypeExtensionTest0457.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0458))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0458, GeneratedExtensions.VolumeArchetypeExtensionTest0458.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0459))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0459, GeneratedExtensions.VolumeArchetypeExtensionTest0459.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0460))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0460, GeneratedExtensions.VolumeArchetypeExtensionTest0460.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0461))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0461, GeneratedExtensions.VolumeArchetypeExtensionTest0461.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0462))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0462, GeneratedExtensions.VolumeArchetypeExtensionTest0462.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0463))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0463, GeneratedExtensions.VolumeArchetypeExtensionTest0463.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0464))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0464, GeneratedExtensions.VolumeArchetypeExtensionTest0464.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0465))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0465, GeneratedExtensions.VolumeArchetypeExtensionTest0465.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0466))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0466, GeneratedExtensions.VolumeArchetypeExtensionTest0466.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0467))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0467, GeneratedExtensions.VolumeArchetypeExtensionTest0467.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0468))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0468, GeneratedExtensions.VolumeArchetypeExtensionTest0468.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0469))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0469, GeneratedExtensions.VolumeArchetypeExtensionTest0469.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0470))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0470, GeneratedExtensions.VolumeArchetypeExtensionTest0470.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0471))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0471, GeneratedExtensions.VolumeArchetypeExtensionTest0471.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0472))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0472, GeneratedExtensions.VolumeArchetypeExtensionTest0472.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0473))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0473, GeneratedExtensions.VolumeArchetypeExtensionTest0473.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0474))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0474, GeneratedExtensions.VolumeArchetypeExtensionTest0474.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0475))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0475, GeneratedExtensions.VolumeArchetypeExtensionTest0475.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0476))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0476, GeneratedExtensions.VolumeArchetypeExtensionTest0476.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0477))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0477, GeneratedExtensions.VolumeArchetypeExtensionTest0477.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0478))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0478, GeneratedExtensions.VolumeArchetypeExtensionTest0478.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0479))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0479, GeneratedExtensions.VolumeArchetypeExtensionTest0479.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0480))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0480, GeneratedExtensions.VolumeArchetypeExtensionTest0480.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0481))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0481, GeneratedExtensions.VolumeArchetypeExtensionTest0481.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0482))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0482, GeneratedExtensions.VolumeArchetypeExtensionTest0482.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0483))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0483, GeneratedExtensions.VolumeArchetypeExtensionTest0483.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0484))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0484, GeneratedExtensions.VolumeArchetypeExtensionTest0484.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0485))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0485, GeneratedExtensions.VolumeArchetypeExtensionTest0485.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0486))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0486, GeneratedExtensions.VolumeArchetypeExtensionTest0486.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0487))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0487, GeneratedExtensions.VolumeArchetypeExtensionTest0487.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0488))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0488, GeneratedExtensions.VolumeArchetypeExtensionTest0488.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0489))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0489, GeneratedExtensions.VolumeArchetypeExtensionTest0489.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0490))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0490, GeneratedExtensions.VolumeArchetypeExtensionTest0490.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0491))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0491, GeneratedExtensions.VolumeArchetypeExtensionTest0491.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0492))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0492, GeneratedExtensions.VolumeArchetypeExtensionTest0492.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0493))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0493, GeneratedExtensions.VolumeArchetypeExtensionTest0493.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0494))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0494, GeneratedExtensions.VolumeArchetypeExtensionTest0494.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0495))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0495, GeneratedExtensions.VolumeArchetypeExtensionTest0495.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0496))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0496, GeneratedExtensions.VolumeArchetypeExtensionTest0496.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0497))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0497, GeneratedExtensions.VolumeArchetypeExtensionTest0497.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0498))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0498, GeneratedExtensions.VolumeArchetypeExtensionTest0498.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0499))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0499, GeneratedExtensions.VolumeArchetypeExtensionTest0499.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0500))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0500, GeneratedExtensions.VolumeArchetypeExtensionTest0500.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0501))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0501, GeneratedExtensions.VolumeArchetypeExtensionTest0501.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0502))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0502, GeneratedExtensions.VolumeArchetypeExtensionTest0502.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0503))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0503, GeneratedExtensions.VolumeArchetypeExtensionTest0503.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0504))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0504, GeneratedExtensions.VolumeArchetypeExtensionTest0504.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0505))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0505, GeneratedExtensions.VolumeArchetypeExtensionTest0505.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0506))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0506, GeneratedExtensions.VolumeArchetypeExtensionTest0506.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0507))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0507, GeneratedExtensions.VolumeArchetypeExtensionTest0507.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0508))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0508, GeneratedExtensions.VolumeArchetypeExtensionTest0508.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0509))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0509, GeneratedExtensions.VolumeArchetypeExtensionTest0509.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0510))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0510, GeneratedExtensions.VolumeArchetypeExtensionTest0510.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0511))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0511, GeneratedExtensions.VolumeArchetypeExtensionTest0511.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0512))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0512, GeneratedExtensions.VolumeArchetypeExtensionTest0512.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0513))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0513, GeneratedExtensions.VolumeArchetypeExtensionTest0513.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0514))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0514, GeneratedExtensions.VolumeArchetypeExtensionTest0514.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0515))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0515, GeneratedExtensions.VolumeArchetypeExtensionTest0515.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0516))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0516, GeneratedExtensions.VolumeArchetypeExtensionTest0516.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0517))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0517, GeneratedExtensions.VolumeArchetypeExtensionTest0517.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0518))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0518, GeneratedExtensions.VolumeArchetypeExtensionTest0518.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0519))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0519, GeneratedExtensions.VolumeArchetypeExtensionTest0519.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0520))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0520, GeneratedExtensions.VolumeArchetypeExtensionTest0520.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0521))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0521, GeneratedExtensions.VolumeArchetypeExtensionTest0521.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0522))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0522, GeneratedExtensions.VolumeArchetypeExtensionTest0522.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0523))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0523, GeneratedExtensions.VolumeArchetypeExtensionTest0523.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0524))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0524, GeneratedExtensions.VolumeArchetypeExtensionTest0524.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0525))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0525, GeneratedExtensions.VolumeArchetypeExtensionTest0525.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0526))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0526, GeneratedExtensions.VolumeArchetypeExtensionTest0526.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0527))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0527, GeneratedExtensions.VolumeArchetypeExtensionTest0527.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0528))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0528, GeneratedExtensions.VolumeArchetypeExtensionTest0528.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0529))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0529, GeneratedExtensions.VolumeArchetypeExtensionTest0529.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0530))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0530, GeneratedExtensions.VolumeArchetypeExtensionTest0530.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0531))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0531, GeneratedExtensions.VolumeArchetypeExtensionTest0531.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0532))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0532, GeneratedExtensions.VolumeArchetypeExtensionTest0532.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0533))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0533, GeneratedExtensions.VolumeArchetypeExtensionTest0533.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0534))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0534, GeneratedExtensions.VolumeArchetypeExtensionTest0534.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0535))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0535, GeneratedExtensions.VolumeArchetypeExtensionTest0535.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0536))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0536, GeneratedExtensions.VolumeArchetypeExtensionTest0536.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0537))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0537, GeneratedExtensions.VolumeArchetypeExtensionTest0537.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0538))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0538, GeneratedExtensions.VolumeArchetypeExtensionTest0538.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0539))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0539, GeneratedExtensions.VolumeArchetypeExtensionTest0539.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0540))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0540, GeneratedExtensions.VolumeArchetypeExtensionTest0540.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0541))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0541, GeneratedExtensions.VolumeArchetypeExtensionTest0541.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0542))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0542, GeneratedExtensions.VolumeArchetypeExtensionTest0542.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0543))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0543, GeneratedExtensions.VolumeArchetypeExtensionTest0543.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0544))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0544, GeneratedExtensions.VolumeArchetypeExtensionTest0544.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0545))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0545, GeneratedExtensions.VolumeArchetypeExtensionTest0545.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0546))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0546, GeneratedExtensions.VolumeArchetypeExtensionTest0546.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0547))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0547, GeneratedExtensions.VolumeArchetypeExtensionTest0547.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0548))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0548, GeneratedExtensions.VolumeArchetypeExtensionTest0548.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0549))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0549, GeneratedExtensions.VolumeArchetypeExtensionTest0549.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0550))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0550, GeneratedExtensions.VolumeArchetypeExtensionTest0550.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0551))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0551, GeneratedExtensions.VolumeArchetypeExtensionTest0551.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0552))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0552, GeneratedExtensions.VolumeArchetypeExtensionTest0552.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0553))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0553, GeneratedExtensions.VolumeArchetypeExtensionTest0553.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0554))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0554, GeneratedExtensions.VolumeArchetypeExtensionTest0554.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0555))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0555, GeneratedExtensions.VolumeArchetypeExtensionTest0555.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0556))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0556, GeneratedExtensions.VolumeArchetypeExtensionTest0556.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0557))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0557, GeneratedExtensions.VolumeArchetypeExtensionTest0557.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0558))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0558, GeneratedExtensions.VolumeArchetypeExtensionTest0558.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0559))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0559, GeneratedExtensions.VolumeArchetypeExtensionTest0559.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0560))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0560, GeneratedExtensions.VolumeArchetypeExtensionTest0560.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0561))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0561, GeneratedExtensions.VolumeArchetypeExtensionTest0561.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0562))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0562, GeneratedExtensions.VolumeArchetypeExtensionTest0562.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0563))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0563, GeneratedExtensions.VolumeArchetypeExtensionTest0563.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0564))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0564, GeneratedExtensions.VolumeArchetypeExtensionTest0564.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0565))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0565, GeneratedExtensions.VolumeArchetypeExtensionTest0565.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0566))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0566, GeneratedExtensions.VolumeArchetypeExtensionTest0566.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0567))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0567, GeneratedExtensions.VolumeArchetypeExtensionTest0567.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0568))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0568, GeneratedExtensions.VolumeArchetypeExtensionTest0568.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0569))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0569, GeneratedExtensions.VolumeArchetypeExtensionTest0569.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0570))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0570, GeneratedExtensions.VolumeArchetypeExtensionTest0570.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0571))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0571, GeneratedExtensions.VolumeArchetypeExtensionTest0571.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0572))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0572, GeneratedExtensions.VolumeArchetypeExtensionTest0572.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0573))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0573, GeneratedExtensions.VolumeArchetypeExtensionTest0573.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0574))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0574, GeneratedExtensions.VolumeArchetypeExtensionTest0574.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0575))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0575, GeneratedExtensions.VolumeArchetypeExtensionTest0575.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0576))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0576, GeneratedExtensions.VolumeArchetypeExtensionTest0576.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0577))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0577, GeneratedExtensions.VolumeArchetypeExtensionTest0577.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0578))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0578, GeneratedExtensions.VolumeArchetypeExtensionTest0578.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0579))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0579, GeneratedExtensions.VolumeArchetypeExtensionTest0579.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0580))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0580, GeneratedExtensions.VolumeArchetypeExtensionTest0580.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0581))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0581, GeneratedExtensions.VolumeArchetypeExtensionTest0581.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0582))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0582, GeneratedExtensions.VolumeArchetypeExtensionTest0582.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0583))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0583, GeneratedExtensions.VolumeArchetypeExtensionTest0583.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0584))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0584, GeneratedExtensions.VolumeArchetypeExtensionTest0584.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0585))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0585, GeneratedExtensions.VolumeArchetypeExtensionTest0585.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0586))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0586, GeneratedExtensions.VolumeArchetypeExtensionTest0586.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0587))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0587, GeneratedExtensions.VolumeArchetypeExtensionTest0587.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0588))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0588, GeneratedExtensions.VolumeArchetypeExtensionTest0588.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0589))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0589, GeneratedExtensions.VolumeArchetypeExtensionTest0589.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0590))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0590, GeneratedExtensions.VolumeArchetypeExtensionTest0590.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0591))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0591, GeneratedExtensions.VolumeArchetypeExtensionTest0591.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0592))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0592, GeneratedExtensions.VolumeArchetypeExtensionTest0592.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0593))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0593, GeneratedExtensions.VolumeArchetypeExtensionTest0593.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0594))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0594, GeneratedExtensions.VolumeArchetypeExtensionTest0594.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0595))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0595, GeneratedExtensions.VolumeArchetypeExtensionTest0595.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0596))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0596, GeneratedExtensions.VolumeArchetypeExtensionTest0596.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0597))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0597, GeneratedExtensions.VolumeArchetypeExtensionTest0597.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0598))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0598, GeneratedExtensions.VolumeArchetypeExtensionTest0598.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0599))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0599, GeneratedExtensions.VolumeArchetypeExtensionTest0599.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0600))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0600, GeneratedExtensions.VolumeArchetypeExtensionTest0600.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0601))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0601, GeneratedExtensions.VolumeArchetypeExtensionTest0601.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0602))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0602, GeneratedExtensions.VolumeArchetypeExtensionTest0602.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0603))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0603, GeneratedExtensions.VolumeArchetypeExtensionTest0603.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0604))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0604, GeneratedExtensions.VolumeArchetypeExtensionTest0604.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0605))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0605, GeneratedExtensions.VolumeArchetypeExtensionTest0605.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0606))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0606, GeneratedExtensions.VolumeArchetypeExtensionTest0606.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0607))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0607, GeneratedExtensions.VolumeArchetypeExtensionTest0607.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0608))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0608, GeneratedExtensions.VolumeArchetypeExtensionTest0608.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0609))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0609, GeneratedExtensions.VolumeArchetypeExtensionTest0609.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0610))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0610, GeneratedExtensions.VolumeArchetypeExtensionTest0610.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0611))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0611, GeneratedExtensions.VolumeArchetypeExtensionTest0611.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0612))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0612, GeneratedExtensions.VolumeArchetypeExtensionTest0612.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0613))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0613, GeneratedExtensions.VolumeArchetypeExtensionTest0613.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0614))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0614, GeneratedExtensions.VolumeArchetypeExtensionTest0614.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0615))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0615, GeneratedExtensions.VolumeArchetypeExtensionTest0615.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0616))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0616, GeneratedExtensions.VolumeArchetypeExtensionTest0616.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0617))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0617, GeneratedExtensions.VolumeArchetypeExtensionTest0617.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0618))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0618, GeneratedExtensions.VolumeArchetypeExtensionTest0618.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0619))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0619, GeneratedExtensions.VolumeArchetypeExtensionTest0619.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0620))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0620, GeneratedExtensions.VolumeArchetypeExtensionTest0620.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0621))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0621, GeneratedExtensions.VolumeArchetypeExtensionTest0621.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0622))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0622, GeneratedExtensions.VolumeArchetypeExtensionTest0622.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0623))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0623, GeneratedExtensions.VolumeArchetypeExtensionTest0623.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0624))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0624, GeneratedExtensions.VolumeArchetypeExtensionTest0624.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0625))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0625, GeneratedExtensions.VolumeArchetypeExtensionTest0625.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0626))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0626, GeneratedExtensions.VolumeArchetypeExtensionTest0626.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0627))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0627, GeneratedExtensions.VolumeArchetypeExtensionTest0627.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0628))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0628, GeneratedExtensions.VolumeArchetypeExtensionTest0628.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0629))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0629, GeneratedExtensions.VolumeArchetypeExtensionTest0629.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0630))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0630, GeneratedExtensions.VolumeArchetypeExtensionTest0630.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0631))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0631, GeneratedExtensions.VolumeArchetypeExtensionTest0631.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0632))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0632, GeneratedExtensions.VolumeArchetypeExtensionTest0632.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0633))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0633, GeneratedExtensions.VolumeArchetypeExtensionTest0633.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0634))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0634, GeneratedExtensions.VolumeArchetypeExtensionTest0634.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0635))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0635, GeneratedExtensions.VolumeArchetypeExtensionTest0635.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0636))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0636, GeneratedExtensions.VolumeArchetypeExtensionTest0636.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0637))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0637, GeneratedExtensions.VolumeArchetypeExtensionTest0637.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0638))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0638, GeneratedExtensions.VolumeArchetypeExtensionTest0638.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0639))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0639, GeneratedExtensions.VolumeArchetypeExtensionTest0639.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0640))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0640, GeneratedExtensions.VolumeArchetypeExtensionTest0640.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0641))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0641, GeneratedExtensions.VolumeArchetypeExtensionTest0641.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0642))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0642, GeneratedExtensions.VolumeArchetypeExtensionTest0642.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0643))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0643, GeneratedExtensions.VolumeArchetypeExtensionTest0643.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0644))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0644, GeneratedExtensions.VolumeArchetypeExtensionTest0644.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0645))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0645, GeneratedExtensions.VolumeArchetypeExtensionTest0645.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0646))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0646, GeneratedExtensions.VolumeArchetypeExtensionTest0646.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0647))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0647, GeneratedExtensions.VolumeArchetypeExtensionTest0647.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0648))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0648, GeneratedExtensions.VolumeArchetypeExtensionTest0648.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0649))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0649, GeneratedExtensions.VolumeArchetypeExtensionTest0649.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0650))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0650, GeneratedExtensions.VolumeArchetypeExtensionTest0650.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0651))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0651, GeneratedExtensions.VolumeArchetypeExtensionTest0651.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0652))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0652, GeneratedExtensions.VolumeArchetypeExtensionTest0652.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0653))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0653, GeneratedExtensions.VolumeArchetypeExtensionTest0653.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0654))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0654, GeneratedExtensions.VolumeArchetypeExtensionTest0654.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0655))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0655, GeneratedExtensions.VolumeArchetypeExtensionTest0655.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0656))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0656, GeneratedExtensions.VolumeArchetypeExtensionTest0656.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0657))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0657, GeneratedExtensions.VolumeArchetypeExtensionTest0657.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0658))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0658, GeneratedExtensions.VolumeArchetypeExtensionTest0658.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0659))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0659, GeneratedExtensions.VolumeArchetypeExtensionTest0659.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0660))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0660, GeneratedExtensions.VolumeArchetypeExtensionTest0660.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0661))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0661, GeneratedExtensions.VolumeArchetypeExtensionTest0661.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0662))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0662, GeneratedExtensions.VolumeArchetypeExtensionTest0662.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0663))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0663, GeneratedExtensions.VolumeArchetypeExtensionTest0663.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0664))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0664, GeneratedExtensions.VolumeArchetypeExtensionTest0664.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0665))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0665, GeneratedExtensions.VolumeArchetypeExtensionTest0665.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0666))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0666, GeneratedExtensions.VolumeArchetypeExtensionTest0666.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0667))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0667, GeneratedExtensions.VolumeArchetypeExtensionTest0667.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0668))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0668, GeneratedExtensions.VolumeArchetypeExtensionTest0668.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0669))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0669, GeneratedExtensions.VolumeArchetypeExtensionTest0669.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0670))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0670, GeneratedExtensions.VolumeArchetypeExtensionTest0670.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0671))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0671, GeneratedExtensions.VolumeArchetypeExtensionTest0671.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0672))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0672, GeneratedExtensions.VolumeArchetypeExtensionTest0672.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0673))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0673, GeneratedExtensions.VolumeArchetypeExtensionTest0673.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0674))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0674, GeneratedExtensions.VolumeArchetypeExtensionTest0674.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0675))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0675, GeneratedExtensions.VolumeArchetypeExtensionTest0675.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0676))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0676, GeneratedExtensions.VolumeArchetypeExtensionTest0676.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0677))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0677, GeneratedExtensions.VolumeArchetypeExtensionTest0677.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0678))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0678, GeneratedExtensions.VolumeArchetypeExtensionTest0678.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0679))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0679, GeneratedExtensions.VolumeArchetypeExtensionTest0679.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0680))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0680, GeneratedExtensions.VolumeArchetypeExtensionTest0680.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0681))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0681, GeneratedExtensions.VolumeArchetypeExtensionTest0681.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0682))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0682, GeneratedExtensions.VolumeArchetypeExtensionTest0682.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0683))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0683, GeneratedExtensions.VolumeArchetypeExtensionTest0683.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0684))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0684, GeneratedExtensions.VolumeArchetypeExtensionTest0684.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0685))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0685, GeneratedExtensions.VolumeArchetypeExtensionTest0685.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0686))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0686, GeneratedExtensions.VolumeArchetypeExtensionTest0686.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0687))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0687, GeneratedExtensions.VolumeArchetypeExtensionTest0687.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0688))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0688, GeneratedExtensions.VolumeArchetypeExtensionTest0688.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0689))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0689, GeneratedExtensions.VolumeArchetypeExtensionTest0689.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0690))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0690, GeneratedExtensions.VolumeArchetypeExtensionTest0690.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0691))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0691, GeneratedExtensions.VolumeArchetypeExtensionTest0691.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0692))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0692, GeneratedExtensions.VolumeArchetypeExtensionTest0692.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0693))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0693, GeneratedExtensions.VolumeArchetypeExtensionTest0693.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0694))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0694, GeneratedExtensions.VolumeArchetypeExtensionTest0694.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0695))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0695, GeneratedExtensions.VolumeArchetypeExtensionTest0695.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0696))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0696, GeneratedExtensions.VolumeArchetypeExtensionTest0696.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0697))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0697, GeneratedExtensions.VolumeArchetypeExtensionTest0697.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0698))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0698, GeneratedExtensions.VolumeArchetypeExtensionTest0698.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0699))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0699, GeneratedExtensions.VolumeArchetypeExtensionTest0699.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0700))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0700, GeneratedExtensions.VolumeArchetypeExtensionTest0700.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0701))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0701, GeneratedExtensions.VolumeArchetypeExtensionTest0701.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0702))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0702, GeneratedExtensions.VolumeArchetypeExtensionTest0702.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0703))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0703, GeneratedExtensions.VolumeArchetypeExtensionTest0703.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0704))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0704, GeneratedExtensions.VolumeArchetypeExtensionTest0704.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0705))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0705, GeneratedExtensions.VolumeArchetypeExtensionTest0705.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0706))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0706, GeneratedExtensions.VolumeArchetypeExtensionTest0706.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0707))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0707, GeneratedExtensions.VolumeArchetypeExtensionTest0707.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0708))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0708, GeneratedExtensions.VolumeArchetypeExtensionTest0708.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0709))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0709, GeneratedExtensions.VolumeArchetypeExtensionTest0709.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0710))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0710, GeneratedExtensions.VolumeArchetypeExtensionTest0710.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0711))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0711, GeneratedExtensions.VolumeArchetypeExtensionTest0711.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0712))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0712, GeneratedExtensions.VolumeArchetypeExtensionTest0712.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0713))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0713, GeneratedExtensions.VolumeArchetypeExtensionTest0713.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0714))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0714, GeneratedExtensions.VolumeArchetypeExtensionTest0714.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0715))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0715, GeneratedExtensions.VolumeArchetypeExtensionTest0715.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0716))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0716, GeneratedExtensions.VolumeArchetypeExtensionTest0716.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0717))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0717, GeneratedExtensions.VolumeArchetypeExtensionTest0717.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0718))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0718, GeneratedExtensions.VolumeArchetypeExtensionTest0718.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0719))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0719, GeneratedExtensions.VolumeArchetypeExtensionTest0719.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0720))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0720, GeneratedExtensions.VolumeArchetypeExtensionTest0720.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0721))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0721, GeneratedExtensions.VolumeArchetypeExtensionTest0721.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0722))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0722, GeneratedExtensions.VolumeArchetypeExtensionTest0722.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0723))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0723, GeneratedExtensions.VolumeArchetypeExtensionTest0723.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0724))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0724, GeneratedExtensions.VolumeArchetypeExtensionTest0724.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0725))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0725, GeneratedExtensions.VolumeArchetypeExtensionTest0725.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0726))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0726, GeneratedExtensions.VolumeArchetypeExtensionTest0726.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0727))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0727, GeneratedExtensions.VolumeArchetypeExtensionTest0727.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0728))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0728, GeneratedExtensions.VolumeArchetypeExtensionTest0728.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0729))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0729, GeneratedExtensions.VolumeArchetypeExtensionTest0729.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0730))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0730, GeneratedExtensions.VolumeArchetypeExtensionTest0730.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0731))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0731, GeneratedExtensions.VolumeArchetypeExtensionTest0731.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0732))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0732, GeneratedExtensions.VolumeArchetypeExtensionTest0732.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0733))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0733, GeneratedExtensions.VolumeArchetypeExtensionTest0733.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0734))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0734, GeneratedExtensions.VolumeArchetypeExtensionTest0734.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0735))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0735, GeneratedExtensions.VolumeArchetypeExtensionTest0735.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0736))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0736, GeneratedExtensions.VolumeArchetypeExtensionTest0736.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0737))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0737, GeneratedExtensions.VolumeArchetypeExtensionTest0737.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0738))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0738, GeneratedExtensions.VolumeArchetypeExtensionTest0738.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0739))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0739, GeneratedExtensions.VolumeArchetypeExtensionTest0739.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0740))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0740, GeneratedExtensions.VolumeArchetypeExtensionTest0740.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0741))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0741, GeneratedExtensions.VolumeArchetypeExtensionTest0741.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0742))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0742, GeneratedExtensions.VolumeArchetypeExtensionTest0742.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0743))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0743, GeneratedExtensions.VolumeArchetypeExtensionTest0743.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0744))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0744, GeneratedExtensions.VolumeArchetypeExtensionTest0744.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0745))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0745, GeneratedExtensions.VolumeArchetypeExtensionTest0745.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0746))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0746, GeneratedExtensions.VolumeArchetypeExtensionTest0746.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0747))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0747, GeneratedExtensions.VolumeArchetypeExtensionTest0747.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0748))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0748, GeneratedExtensions.VolumeArchetypeExtensionTest0748.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0749))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0749, GeneratedExtensions.VolumeArchetypeExtensionTest0749.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0750))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0750, GeneratedExtensions.VolumeArchetypeExtensionTest0750.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0751))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0751, GeneratedExtensions.VolumeArchetypeExtensionTest0751.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0752))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0752, GeneratedExtensions.VolumeArchetypeExtensionTest0752.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0753))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0753, GeneratedExtensions.VolumeArchetypeExtensionTest0753.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0754))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0754, GeneratedExtensions.VolumeArchetypeExtensionTest0754.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0755))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0755, GeneratedExtensions.VolumeArchetypeExtensionTest0755.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0756))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0756, GeneratedExtensions.VolumeArchetypeExtensionTest0756.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0757))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0757, GeneratedExtensions.VolumeArchetypeExtensionTest0757.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0758))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0758, GeneratedExtensions.VolumeArchetypeExtensionTest0758.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0759))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0759, GeneratedExtensions.VolumeArchetypeExtensionTest0759.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0760))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0760, GeneratedExtensions.VolumeArchetypeExtensionTest0760.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0761))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0761, GeneratedExtensions.VolumeArchetypeExtensionTest0761.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0762))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0762, GeneratedExtensions.VolumeArchetypeExtensionTest0762.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0763))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0763, GeneratedExtensions.VolumeArchetypeExtensionTest0763.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0764))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0764, GeneratedExtensions.VolumeArchetypeExtensionTest0764.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0765))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0765, GeneratedExtensions.VolumeArchetypeExtensionTest0765.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0766))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0766, GeneratedExtensions.VolumeArchetypeExtensionTest0766.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0767))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0767, GeneratedExtensions.VolumeArchetypeExtensionTest0767.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0768))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0768, GeneratedExtensions.VolumeArchetypeExtensionTest0768.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0769))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0769, GeneratedExtensions.VolumeArchetypeExtensionTest0769.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0770))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0770, GeneratedExtensions.VolumeArchetypeExtensionTest0770.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0771))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0771, GeneratedExtensions.VolumeArchetypeExtensionTest0771.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0772))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0772, GeneratedExtensions.VolumeArchetypeExtensionTest0772.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0773))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0773, GeneratedExtensions.VolumeArchetypeExtensionTest0773.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0774))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0774, GeneratedExtensions.VolumeArchetypeExtensionTest0774.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0775))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0775, GeneratedExtensions.VolumeArchetypeExtensionTest0775.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0776))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0776, GeneratedExtensions.VolumeArchetypeExtensionTest0776.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0777))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0777, GeneratedExtensions.VolumeArchetypeExtensionTest0777.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0778))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0778, GeneratedExtensions.VolumeArchetypeExtensionTest0778.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0779))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0779, GeneratedExtensions.VolumeArchetypeExtensionTest0779.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0780))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0780, GeneratedExtensions.VolumeArchetypeExtensionTest0780.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0781))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0781, GeneratedExtensions.VolumeArchetypeExtensionTest0781.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0782))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0782, GeneratedExtensions.VolumeArchetypeExtensionTest0782.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0783))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0783, GeneratedExtensions.VolumeArchetypeExtensionTest0783.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0784))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0784, GeneratedExtensions.VolumeArchetypeExtensionTest0784.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0785))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0785, GeneratedExtensions.VolumeArchetypeExtensionTest0785.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0786))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0786, GeneratedExtensions.VolumeArchetypeExtensionTest0786.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0787))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0787, GeneratedExtensions.VolumeArchetypeExtensionTest0787.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0788))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0788, GeneratedExtensions.VolumeArchetypeExtensionTest0788.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0789))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0789, GeneratedExtensions.VolumeArchetypeExtensionTest0789.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0790))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0790, GeneratedExtensions.VolumeArchetypeExtensionTest0790.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0791))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0791, GeneratedExtensions.VolumeArchetypeExtensionTest0791.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0792))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0792, GeneratedExtensions.VolumeArchetypeExtensionTest0792.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0793))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0793, GeneratedExtensions.VolumeArchetypeExtensionTest0793.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0794))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0794, GeneratedExtensions.VolumeArchetypeExtensionTest0794.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0795))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0795, GeneratedExtensions.VolumeArchetypeExtensionTest0795.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0796))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0796, GeneratedExtensions.VolumeArchetypeExtensionTest0796.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0797))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0797, GeneratedExtensions.VolumeArchetypeExtensionTest0797.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0798))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0798, GeneratedExtensions.VolumeArchetypeExtensionTest0798.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0799))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0799, GeneratedExtensions.VolumeArchetypeExtensionTest0799.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0800))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0800, GeneratedExtensions.VolumeArchetypeExtensionTest0800.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0801))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0801, GeneratedExtensions.VolumeArchetypeExtensionTest0801.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0802))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0802, GeneratedExtensions.VolumeArchetypeExtensionTest0802.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0803))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0803, GeneratedExtensions.VolumeArchetypeExtensionTest0803.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0804))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0804, GeneratedExtensions.VolumeArchetypeExtensionTest0804.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0805))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0805, GeneratedExtensions.VolumeArchetypeExtensionTest0805.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0806))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0806, GeneratedExtensions.VolumeArchetypeExtensionTest0806.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0807))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0807, GeneratedExtensions.VolumeArchetypeExtensionTest0807.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0808))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0808, GeneratedExtensions.VolumeArchetypeExtensionTest0808.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0809))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0809, GeneratedExtensions.VolumeArchetypeExtensionTest0809.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0810))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0810, GeneratedExtensions.VolumeArchetypeExtensionTest0810.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0811))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0811, GeneratedExtensions.VolumeArchetypeExtensionTest0811.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0812))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0812, GeneratedExtensions.VolumeArchetypeExtensionTest0812.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0813))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0813, GeneratedExtensions.VolumeArchetypeExtensionTest0813.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0814))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0814, GeneratedExtensions.VolumeArchetypeExtensionTest0814.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0815))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0815, GeneratedExtensions.VolumeArchetypeExtensionTest0815.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0816))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0816, GeneratedExtensions.VolumeArchetypeExtensionTest0816.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0817))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0817, GeneratedExtensions.VolumeArchetypeExtensionTest0817.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0818))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0818, GeneratedExtensions.VolumeArchetypeExtensionTest0818.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0819))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0819, GeneratedExtensions.VolumeArchetypeExtensionTest0819.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0820))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0820, GeneratedExtensions.VolumeArchetypeExtensionTest0820.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0821))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0821, GeneratedExtensions.VolumeArchetypeExtensionTest0821.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0822))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0822, GeneratedExtensions.VolumeArchetypeExtensionTest0822.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0823))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0823, GeneratedExtensions.VolumeArchetypeExtensionTest0823.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0824))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0824, GeneratedExtensions.VolumeArchetypeExtensionTest0824.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0825))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0825, GeneratedExtensions.VolumeArchetypeExtensionTest0825.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0826))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0826, GeneratedExtensions.VolumeArchetypeExtensionTest0826.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0827))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0827, GeneratedExtensions.VolumeArchetypeExtensionTest0827.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0828))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0828, GeneratedExtensions.VolumeArchetypeExtensionTest0828.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0829))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0829, GeneratedExtensions.VolumeArchetypeExtensionTest0829.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0830))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0830, GeneratedExtensions.VolumeArchetypeExtensionTest0830.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0831))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0831, GeneratedExtensions.VolumeArchetypeExtensionTest0831.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0832))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0832, GeneratedExtensions.VolumeArchetypeExtensionTest0832.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0833))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0833, GeneratedExtensions.VolumeArchetypeExtensionTest0833.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0834))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0834, GeneratedExtensions.VolumeArchetypeExtensionTest0834.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0835))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0835, GeneratedExtensions.VolumeArchetypeExtensionTest0835.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0836))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0836, GeneratedExtensions.VolumeArchetypeExtensionTest0836.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0837))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0837, GeneratedExtensions.VolumeArchetypeExtensionTest0837.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0838))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0838, GeneratedExtensions.VolumeArchetypeExtensionTest0838.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0839))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0839, GeneratedExtensions.VolumeArchetypeExtensionTest0839.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0840))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0840, GeneratedExtensions.VolumeArchetypeExtensionTest0840.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0841))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0841, GeneratedExtensions.VolumeArchetypeExtensionTest0841.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0842))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0842, GeneratedExtensions.VolumeArchetypeExtensionTest0842.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0843))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0843, GeneratedExtensions.VolumeArchetypeExtensionTest0843.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0844))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0844, GeneratedExtensions.VolumeArchetypeExtensionTest0844.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0845))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0845, GeneratedExtensions.VolumeArchetypeExtensionTest0845.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0846))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0846, GeneratedExtensions.VolumeArchetypeExtensionTest0846.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0847))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0847, GeneratedExtensions.VolumeArchetypeExtensionTest0847.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0848))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0848, GeneratedExtensions.VolumeArchetypeExtensionTest0848.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0849))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0849, GeneratedExtensions.VolumeArchetypeExtensionTest0849.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0850))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0850, GeneratedExtensions.VolumeArchetypeExtensionTest0850.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0851))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0851, GeneratedExtensions.VolumeArchetypeExtensionTest0851.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0852))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0852, GeneratedExtensions.VolumeArchetypeExtensionTest0852.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0853))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0853, GeneratedExtensions.VolumeArchetypeExtensionTest0853.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0854))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0854, GeneratedExtensions.VolumeArchetypeExtensionTest0854.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0855))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0855, GeneratedExtensions.VolumeArchetypeExtensionTest0855.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0856))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0856, GeneratedExtensions.VolumeArchetypeExtensionTest0856.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0857))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0857, GeneratedExtensions.VolumeArchetypeExtensionTest0857.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0858))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0858, GeneratedExtensions.VolumeArchetypeExtensionTest0858.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0859))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0859, GeneratedExtensions.VolumeArchetypeExtensionTest0859.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0860))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0860, GeneratedExtensions.VolumeArchetypeExtensionTest0860.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0861))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0861, GeneratedExtensions.VolumeArchetypeExtensionTest0861.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0862))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0862, GeneratedExtensions.VolumeArchetypeExtensionTest0862.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0863))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0863, GeneratedExtensions.VolumeArchetypeExtensionTest0863.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0864))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0864, GeneratedExtensions.VolumeArchetypeExtensionTest0864.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0865))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0865, GeneratedExtensions.VolumeArchetypeExtensionTest0865.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0866))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0866, GeneratedExtensions.VolumeArchetypeExtensionTest0866.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0867))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0867, GeneratedExtensions.VolumeArchetypeExtensionTest0867.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0868))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0868, GeneratedExtensions.VolumeArchetypeExtensionTest0868.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0869))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0869, GeneratedExtensions.VolumeArchetypeExtensionTest0869.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0870))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0870, GeneratedExtensions.VolumeArchetypeExtensionTest0870.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0871))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0871, GeneratedExtensions.VolumeArchetypeExtensionTest0871.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0872))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0872, GeneratedExtensions.VolumeArchetypeExtensionTest0872.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0873))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0873, GeneratedExtensions.VolumeArchetypeExtensionTest0873.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0874))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0874, GeneratedExtensions.VolumeArchetypeExtensionTest0874.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0875))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0875, GeneratedExtensions.VolumeArchetypeExtensionTest0875.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0876))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0876, GeneratedExtensions.VolumeArchetypeExtensionTest0876.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0877))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0877, GeneratedExtensions.VolumeArchetypeExtensionTest0877.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0878))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0878, GeneratedExtensions.VolumeArchetypeExtensionTest0878.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0879))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0879, GeneratedExtensions.VolumeArchetypeExtensionTest0879.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0880))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0880, GeneratedExtensions.VolumeArchetypeExtensionTest0880.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0881))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0881, GeneratedExtensions.VolumeArchetypeExtensionTest0881.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0882))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0882, GeneratedExtensions.VolumeArchetypeExtensionTest0882.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0883))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0883, GeneratedExtensions.VolumeArchetypeExtensionTest0883.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0884))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0884, GeneratedExtensions.VolumeArchetypeExtensionTest0884.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0885))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0885, GeneratedExtensions.VolumeArchetypeExtensionTest0885.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0886))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0886, GeneratedExtensions.VolumeArchetypeExtensionTest0886.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0887))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0887, GeneratedExtensions.VolumeArchetypeExtensionTest0887.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0888))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0888, GeneratedExtensions.VolumeArchetypeExtensionTest0888.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0889))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0889, GeneratedExtensions.VolumeArchetypeExtensionTest0889.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0890))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0890, GeneratedExtensions.VolumeArchetypeExtensionTest0890.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0891))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0891, GeneratedExtensions.VolumeArchetypeExtensionTest0891.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0892))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0892, GeneratedExtensions.VolumeArchetypeExtensionTest0892.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0893))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0893, GeneratedExtensions.VolumeArchetypeExtensionTest0893.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0894))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0894, GeneratedExtensions.VolumeArchetypeExtensionTest0894.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0895))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0895, GeneratedExtensions.VolumeArchetypeExtensionTest0895.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0896))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0896, GeneratedExtensions.VolumeArchetypeExtensionTest0896.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0897))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0897, GeneratedExtensions.VolumeArchetypeExtensionTest0897.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0898))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0898, GeneratedExtensions.VolumeArchetypeExtensionTest0898.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0899))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0899, GeneratedExtensions.VolumeArchetypeExtensionTest0899.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0900))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0900, GeneratedExtensions.VolumeArchetypeExtensionTest0900.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0901))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0901, GeneratedExtensions.VolumeArchetypeExtensionTest0901.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0902))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0902, GeneratedExtensions.VolumeArchetypeExtensionTest0902.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0903))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0903, GeneratedExtensions.VolumeArchetypeExtensionTest0903.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0904))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0904, GeneratedExtensions.VolumeArchetypeExtensionTest0904.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0905))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0905, GeneratedExtensions.VolumeArchetypeExtensionTest0905.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0906))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0906, GeneratedExtensions.VolumeArchetypeExtensionTest0906.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0907))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0907, GeneratedExtensions.VolumeArchetypeExtensionTest0907.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0908))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0908, GeneratedExtensions.VolumeArchetypeExtensionTest0908.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0909))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0909, GeneratedExtensions.VolumeArchetypeExtensionTest0909.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0910))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0910, GeneratedExtensions.VolumeArchetypeExtensionTest0910.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0911))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0911, GeneratedExtensions.VolumeArchetypeExtensionTest0911.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0912))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0912, GeneratedExtensions.VolumeArchetypeExtensionTest0912.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0913))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0913, GeneratedExtensions.VolumeArchetypeExtensionTest0913.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0914))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0914, GeneratedExtensions.VolumeArchetypeExtensionTest0914.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0915))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0915, GeneratedExtensions.VolumeArchetypeExtensionTest0915.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0916))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0916, GeneratedExtensions.VolumeArchetypeExtensionTest0916.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0917))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0917, GeneratedExtensions.VolumeArchetypeExtensionTest0917.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0918))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0918, GeneratedExtensions.VolumeArchetypeExtensionTest0918.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0919))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0919, GeneratedExtensions.VolumeArchetypeExtensionTest0919.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0920))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0920, GeneratedExtensions.VolumeArchetypeExtensionTest0920.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0921))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0921, GeneratedExtensions.VolumeArchetypeExtensionTest0921.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0922))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0922, GeneratedExtensions.VolumeArchetypeExtensionTest0922.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0923))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0923, GeneratedExtensions.VolumeArchetypeExtensionTest0923.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0924))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0924, GeneratedExtensions.VolumeArchetypeExtensionTest0924.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0925))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0925, GeneratedExtensions.VolumeArchetypeExtensionTest0925.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0926))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0926, GeneratedExtensions.VolumeArchetypeExtensionTest0926.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0927))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0927, GeneratedExtensions.VolumeArchetypeExtensionTest0927.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0928))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0928, GeneratedExtensions.VolumeArchetypeExtensionTest0928.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0929))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0929, GeneratedExtensions.VolumeArchetypeExtensionTest0929.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0930))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0930, GeneratedExtensions.VolumeArchetypeExtensionTest0930.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0931))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0931, GeneratedExtensions.VolumeArchetypeExtensionTest0931.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0932))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0932, GeneratedExtensions.VolumeArchetypeExtensionTest0932.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0933))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0933, GeneratedExtensions.VolumeArchetypeExtensionTest0933.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0934))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0934, GeneratedExtensions.VolumeArchetypeExtensionTest0934.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0935))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0935, GeneratedExtensions.VolumeArchetypeExtensionTest0935.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0936))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0936, GeneratedExtensions.VolumeArchetypeExtensionTest0936.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0937))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0937, GeneratedExtensions.VolumeArchetypeExtensionTest0937.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0938))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0938, GeneratedExtensions.VolumeArchetypeExtensionTest0938.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0939))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0939, GeneratedExtensions.VolumeArchetypeExtensionTest0939.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0940))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0940, GeneratedExtensions.VolumeArchetypeExtensionTest0940.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0941))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0941, GeneratedExtensions.VolumeArchetypeExtensionTest0941.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0942))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0942, GeneratedExtensions.VolumeArchetypeExtensionTest0942.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0943))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0943, GeneratedExtensions.VolumeArchetypeExtensionTest0943.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0944))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0944, GeneratedExtensions.VolumeArchetypeExtensionTest0944.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0945))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0945, GeneratedExtensions.VolumeArchetypeExtensionTest0945.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0946))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0946, GeneratedExtensions.VolumeArchetypeExtensionTest0946.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0947))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0947, GeneratedExtensions.VolumeArchetypeExtensionTest0947.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0948))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0948, GeneratedExtensions.VolumeArchetypeExtensionTest0948.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0949))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0949, GeneratedExtensions.VolumeArchetypeExtensionTest0949.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0950))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0950, GeneratedExtensions.VolumeArchetypeExtensionTest0950.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0951))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0951, GeneratedExtensions.VolumeArchetypeExtensionTest0951.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0952))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0952, GeneratedExtensions.VolumeArchetypeExtensionTest0952.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0953))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0953, GeneratedExtensions.VolumeArchetypeExtensionTest0953.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0954))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0954, GeneratedExtensions.VolumeArchetypeExtensionTest0954.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0955))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0955, GeneratedExtensions.VolumeArchetypeExtensionTest0955.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0956))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0956, GeneratedExtensions.VolumeArchetypeExtensionTest0956.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0957))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0957, GeneratedExtensions.VolumeArchetypeExtensionTest0957.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0958))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0958, GeneratedExtensions.VolumeArchetypeExtensionTest0958.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0959))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0959, GeneratedExtensions.VolumeArchetypeExtensionTest0959.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0960))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0960, GeneratedExtensions.VolumeArchetypeExtensionTest0960.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0961))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0961, GeneratedExtensions.VolumeArchetypeExtensionTest0961.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0962))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0962, GeneratedExtensions.VolumeArchetypeExtensionTest0962.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0963))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0963, GeneratedExtensions.VolumeArchetypeExtensionTest0963.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0964))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0964, GeneratedExtensions.VolumeArchetypeExtensionTest0964.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0965))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0965, GeneratedExtensions.VolumeArchetypeExtensionTest0965.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0966))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0966, GeneratedExtensions.VolumeArchetypeExtensionTest0966.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0967))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0967, GeneratedExtensions.VolumeArchetypeExtensionTest0967.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0968))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0968, GeneratedExtensions.VolumeArchetypeExtensionTest0968.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0969))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0969, GeneratedExtensions.VolumeArchetypeExtensionTest0969.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0970))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0970, GeneratedExtensions.VolumeArchetypeExtensionTest0970.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0971))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0971, GeneratedExtensions.VolumeArchetypeExtensionTest0971.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0972))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0972, GeneratedExtensions.VolumeArchetypeExtensionTest0972.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0973))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0973, GeneratedExtensions.VolumeArchetypeExtensionTest0973.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0974))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0974, GeneratedExtensions.VolumeArchetypeExtensionTest0974.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0975))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0975, GeneratedExtensions.VolumeArchetypeExtensionTest0975.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0976))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0976, GeneratedExtensions.VolumeArchetypeExtensionTest0976.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0977))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0977, GeneratedExtensions.VolumeArchetypeExtensionTest0977.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0978))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0978, GeneratedExtensions.VolumeArchetypeExtensionTest0978.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0979))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0979, GeneratedExtensions.VolumeArchetypeExtensionTest0979.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0980))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0980, GeneratedExtensions.VolumeArchetypeExtensionTest0980.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0981))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0981, GeneratedExtensions.VolumeArchetypeExtensionTest0981.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0982))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0982, GeneratedExtensions.VolumeArchetypeExtensionTest0982.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0983))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0983, GeneratedExtensions.VolumeArchetypeExtensionTest0983.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0984))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0984, GeneratedExtensions.VolumeArchetypeExtensionTest0984.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0985))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0985, GeneratedExtensions.VolumeArchetypeExtensionTest0985.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0986))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0986, GeneratedExtensions.VolumeArchetypeExtensionTest0986.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0987))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0987, GeneratedExtensions.VolumeArchetypeExtensionTest0987.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0988))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0988, GeneratedExtensions.VolumeArchetypeExtensionTest0988.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0989))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0989, GeneratedExtensions.VolumeArchetypeExtensionTest0989.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0990))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0990, GeneratedExtensions.VolumeArchetypeExtensionTest0990.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0991))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0991, GeneratedExtensions.VolumeArchetypeExtensionTest0991.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0992))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0992, GeneratedExtensions.VolumeArchetypeExtensionTest0992.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0993))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0993, GeneratedExtensions.VolumeArchetypeExtensionTest0993.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0994))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0994, GeneratedExtensions.VolumeArchetypeExtensionTest0994.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0995))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0995, GeneratedExtensions.VolumeArchetypeExtensionTest0995.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0996))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0996, GeneratedExtensions.VolumeArchetypeExtensionTest0996.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0997))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0997, GeneratedExtensions.VolumeArchetypeExtensionTest0997.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0998))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0998, GeneratedExtensions.VolumeArchetypeExtensionTest0998.Factory>(out _);
+                }
+                if (type == typeof(GeneratedExtensions.VolumeArchetypeExtensionTest0999))
+                {
+                    return archetype.GetOrAddExtension<GeneratedExtensions.VolumeArchetypeExtensionTest0999, GeneratedExtensions.VolumeArchetypeExtensionTest0999.Factory>(out _);
+                }
+                throw new Exception($"Invalid type: {type}");
+            }
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.cs.meta
new file mode 100644
index 00000000000..53cbf96961b
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fb1e31a4a983c7d49973d60f7e8283e4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.tt b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.tt
new file mode 100644
index 00000000000..8ea51ae9d3a
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.tt
@@ -0,0 +1,95 @@
+<#@ template language="C#" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+using System;
+
+namespace UnityEngine.Rendering.Tests
+{
+    partial class VolumeComponentArchetypeTests
+    {
+<#
+    const int totalExtensions = 1000;
+    WriteExtensions(totalExtensions);
+#>
+        partial struct GetAndAddExtensionsTestAction
+        {
+            private partial void ApplyGetTo(VolumeComponentArchetype archetype, Type type)
+            {
+                <# CallOnType(totalExtensions, "archetype.GetExtension<GeneratedExtensions.{0}, GeneratedExtensions.{0}.Factory>(out _); return;"); #>
+            }
+
+            private partial void ApplyGetOrAddTo(VolumeComponentArchetype archetype, Type type)
+            {
+                <# CallOnType(totalExtensions, "archetype.GetOrAddExtension<GeneratedExtensions.{0}, GeneratedExtensions.{0}.Factory>(out _); return;"); #>
+            }
+
+            private partial bool CheckGetTo(VolumeComponentArchetype archetype, Type type)
+            {
+                <# CallOnType(totalExtensions, "return true;"); #>
+            }
+
+            private partial bool CheckGetOrAddTo(VolumeComponentArchetype archetype, Type type)
+            {
+                <# CallOnType(totalExtensions, "return archetype.GetOrAddExtension<GeneratedExtensions.{0}, GeneratedExtensions.{0}.Factory>(out _);"); #>
+            }
+        }
+    }
+}
+<#+
+    static string ToExtensionClassName(int index) => $"VolumeArchetypeExtensionTest{index:0000}";
+
+    void WriteExtensions(int extensionCount)
+    {
+#>
+        class GeneratedExtensions
+        {
+            public static Type[] AllTypes = new Type[]
+            {
+<#+
+        for (var i = 0; i < extensionCount; ++i)
+        {
+            var className = ToExtensionClassName(i);
+#>                typeof(<#+ Write(className); #>),
+<#+
+        }
+#>
+            };
+<#+
+        for (var i = 0; i < extensionCount; ++i)
+        {
+            var className = ToExtensionClassName(i);
+#>
+            public class <#+ Write(className) ;#> : VolumeComponentArchetypeExtension
+            {
+                public struct Factory : IVolumeComponentArchetypeExtensionFactory<<#+ Write(className) ;#>>
+                {
+                    public <#+ Write(className) ;#> Create(VolumeComponentArchetype volumeComponentArchetype)
+                    {
+                        return new <#+ Write(className) ;#>();
+                    }
+                }
+            }
+<#+
+        }
+#>
+        }
+<#+
+    }
+
+    void CallOnType(int extensionCount, string statementFormat)
+    {
+        for (var i = 0; i < extensionCount; ++i)
+        {
+            var className = ToExtensionClassName(i);
+#>
+        if (type == typeof(GeneratedExtensions.<#+Write(className);#>))
+        {
+            <#+ WriteLine(string.Format(statementFormat, className)); #>
+        }
+<#+
+        }
+#>
+        throw new Exception($"Invalid type: {type}");
+<#+
+    }
+#>
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.tt.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.tt.meta
new file mode 100644
index 00000000000..8d538e9266b
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeExtensionTests.tt.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 352c436022297df43a14a37178ce2c57
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypePathAndTypeTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypePathAndTypeTests.cs
new file mode 100644
index 00000000000..41109850d26
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypePathAndTypeTests.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public class VolumeComponentArchetypePathAndTypeTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void SkipObsoleteOrHiddenComponent()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+                if (!archetype.GetOrAddPathAndType(out var extension))
+                    return false;
+
+                foreach (var componentPathAndType in extension.volumeComponentPathAndTypes)
+                {
+                    var customAttributes = componentPathAndType.type.AsType().GetCustomAttributes();
+                    if (customAttributes.Any(attr => attr is HideInInspector or ObsoleteAttribute))
+                        return false;
+                }
+
+                return true;
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void PathIsProvidedByMenuAttribute()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+                if (!archetype.GetOrAddPathAndType(out var extension))
+                    return false;
+
+                foreach (var componentPathAndType in extension.volumeComponentPathAndTypes)
+                {
+                    var attr = componentPathAndType.type.AsType().GetCustomAttribute<VolumeComponentMenu>();
+                    if (attr != null
+                        && !string.IsNullOrEmpty(attr.menu)
+                        && componentPathAndType.path != attr.menu)
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypePathAndTypeTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypePathAndTypeTests.cs.meta
new file mode 100644
index 00000000000..b3e40d4349b
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypePathAndTypeTests.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 025ec3f086b84962baa5d5aeb4a0c009
+timeCreated: 1639495021
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTests.cs
new file mode 100644
index 00000000000..a380f7256b6
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTests.cs
@@ -0,0 +1,234 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public static partial class ArbX
+    {
+        public partial class Arbitraries
+        {
+            public static Arbitrary<VolumeComponentArchetypeTests.GetAndAddExtensionsTestAction> CreateGetAndAddExtensionsTestActionArb()
+                => new VolumeComponentArchetypeTests.GetAndAddExtensionsTestActionArb();
+        }
+    }
+
+    public partial class VolumeComponentArchetypeTests
+    {
+
+        public readonly partial struct GetAndAddExtensionsTestAction
+        {
+            public enum Kind
+            {
+                Get,
+                GetOrAdd,
+            }
+
+            readonly Kind m_Kind;
+            readonly Type m_ExtensionType;
+
+            public override string ToString() => $"{m_Kind}<{m_ExtensionType.Name}>";
+
+            public GetAndAddExtensionsTestAction(Kind kind, Type extensionType)
+            {
+                m_Kind = kind;
+                m_ExtensionType = extensionType;
+            }
+
+            public void ApplyTo([DisallowNull] VolumeComponentArchetype archetype)
+            {
+                switch (m_Kind)
+                {
+                    case Kind.Get:
+                        ApplyGetTo(archetype, m_ExtensionType);
+                        break;
+                    case Kind.GetOrAdd:
+                        ApplyGetOrAddTo(archetype, m_ExtensionType);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+
+            private partial void ApplyGetTo([DisallowNull] VolumeComponentArchetype archetype, [DisallowNull] Type type);
+            private partial void ApplyGetOrAddTo([DisallowNull] VolumeComponentArchetype archetype, [DisallowNull] Type type);
+
+            public bool Check([DisallowNull] VolumeComponentArchetype archetype)
+            {
+                switch (m_Kind)
+                {
+                    case Kind.Get:
+                        return CheckGetTo(archetype, m_ExtensionType);
+                    case Kind.GetOrAdd:
+                        return CheckGetOrAddTo(archetype, m_ExtensionType);
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+
+            private partial bool CheckGetTo([DisallowNull] VolumeComponentArchetype archetype, [DisallowNull] Type type);
+            private partial bool CheckGetOrAddTo([DisallowNull] VolumeComponentArchetype archetype, [DisallowNull] Type type);
+
+        }
+
+        internal class GetAndAddExtensionsTestActionArb : Arbitrary<GetAndAddExtensionsTestAction>
+        {
+            static Type[] s_Types = GeneratedExtensions.AllTypes;
+
+            public override Gen<GetAndAddExtensionsTestAction> Generator => Gen.Elements(s_Types)
+                .Zip(Gen.Choose(0, 1))
+                .Select(tuple => new GetAndAddExtensionsTestAction((GetAndAddExtensionsTestAction.Kind)tuple.Item2, tuple.Item1));
+
+        }
+
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void AsArrayHasAllTypes()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+
+                using (HashSetPool<VolumeComponentType>.Get(out var expectedTypes))
+                {
+                    expectedTypes.UnionWith(types);
+
+                    return expectedTypes.SetEquals(archetype.AsArray());
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property)
+                .ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void CanGetExistingExtension()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+
+                return archetype.GetOrAddDefaultState(out var extension)
+                    && archetype.GetDefaultState(out var extension2)
+                    && ReferenceEquals(extension, extension2);
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void FromEverything()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var database = VolumeComponentDatabase.FromTypes(types);
+                var archetype = VolumeComponentArchetype.FromFilterCached(new EverythingVolumeComponentFilter(), database);
+
+                using (HashSetPool<VolumeComponentType>.Get(out var expectedTypes))
+                {
+                    expectedTypes.UnionWith(types);
+
+                    return expectedTypes.SetEquals(archetype.AsArray());
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void FromIsExplicitlySupportedFilter()
+        {
+            bool Property(VolumeComponentType supportTarget, VolumeComponentType[] types)
+            {
+                var database = VolumeComponentDatabase.FromTypes(types);
+                var archetype = VolumeComponentArchetype.FromFilterCached(
+                    IsExplicitlySupportedVolumeComponentFilter.FromType(supportTarget.AsType()), database);
+
+                using (HashSetPool<VolumeComponentType>.Get(out var expectedTypes))
+                {
+                    expectedTypes.UnionWith(types.Where(
+                        type => IsSupportedOn.IsExplicitlySupportedBy(type.AsType(), supportTarget.AsType())));
+
+                    return expectedTypes.SetEquals(archetype.AsArray());
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType, VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void FromIncludeExclude()
+        {
+            bool Property(VolumeComponentType[][] includes, VolumeComponentType[][] excludes)
+            {
+                var includeArchetypes = includes.Select(VolumeComponentArchetype.FromTypes).ToList();
+                var excludeArchetypes = excludes.Select(VolumeComponentArchetype.FromTypes).ToList();
+                var archetype = VolumeComponentArchetype.FromIncludeExclude(includeArchetypes, excludeArchetypes);
+
+                using (HashSetPool<VolumeComponentType>.Get(out var types))
+                {
+                    foreach (var include in includes)
+                        types.UnionWith(include);
+                    foreach (var exclude in excludes)
+                        types.ExceptWith(exclude);
+
+                    return types.SetEquals(archetype.AsArray());
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[][], VolumeComponentType[][]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void ContainsVolumeType()
+        {
+            bool Property(VolumeComponentType[] types, VolumeComponentType toLookFor)
+            {
+                using (HashSetPool<VolumeComponentType>.Get(out var set))
+                {
+                    set.UnionWith(types);
+
+                    var archetype = VolumeComponentArchetype.FromTypes(types);
+                    var value = archetype.ContainsType(toLookFor);
+                    var expected = set.Contains(toLookFor);
+
+                    return value == expected;
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[], VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+
+        [Test]
+        public void GetAndAddExtensionsTest()
+        {
+            bool Property(VolumeComponentType[] types, GetAndAddExtensionsTestAction[] actions)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+                foreach (var action in actions)
+                    action.ApplyTo(archetype);
+
+                return actions.All(action => action.Check(archetype));
+            }
+
+            Prop.ForAll<VolumeComponentType[], GetAndAddExtensionsTestAction[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+
+        [Test]
+        public void EmptyIsEmpty()
+        {
+            Assert.AreEqual(0, VolumeComponentArchetype.Empty.AsArray().Length);
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTests.cs.meta
new file mode 100644
index 00000000000..8fdaed46cd8
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b05a997f0585a7d45b219ff7c832d8d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTreeProviderTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTreeProviderTests.cs
new file mode 100644
index 00000000000..2919cbc7e97
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTreeProviderTests.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace UnityEngine.Rendering.Tests
+{
+    public class VolumeComponentArchetypeTreeProviderTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void TreeContainsAllTypes()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+                if (!archetype.GetOrAddTreeProvider(out var treeProvider))
+                    return false;
+                if (!archetype.GetPathAndType(out var pathAndType))
+                    return false;
+
+                using (HashSetPool<VolumeComponentType>.Get(out var treeTypes))
+                using (HashSetPool<VolumeComponentType>.Get(out var givenTypes))
+                {
+                    void Traverse(VolumeComponentArchetypeTreeProvider.PathNode node)
+                    {
+                        foreach (var child in node.nodes)
+                        {
+                            Traverse(child);
+                            if (child.type.AsType() != null)
+                                treeTypes.Add(child.type);
+                        }
+                    }
+
+                    Traverse(treeProvider.root);
+                    givenTypes.UnionWith(pathAndType.volumeComponentPathAndTypes.Select(p => p.type));
+
+                    return givenTypes.SetEquals(treeTypes);
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+
+
+        [Test]
+        public void TreePathAreCorrect()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var archetype = VolumeComponentArchetype.FromTypes(types);
+                if (!archetype.GetOrAddTreeProvider(out var treeProvider))
+                    return false;
+                if (!archetype.GetPathAndType(out var pathAndType))
+                    return false;
+
+                using (HashSetPool<VolumeComponentType>.Get(out var treeTypes))
+                using (DictionaryPool<VolumeComponentType, string>.Get(out var typeToPath))
+                {
+                    foreach (var (path, type) in pathAndType.volumeComponentPathAndTypes)
+                    {
+                        typeToPath.Add(type, path);
+                    }
+
+                    bool Traverse(VolumeComponentArchetypeTreeProvider.PathNode node, string path)
+                    {
+                        foreach (var child in node.nodes)
+                        {
+                            var childPath = string.IsNullOrEmpty(path) ? child.name : $"{path}/{child.name}";
+                            if (child.type.AsType() != null)
+                            {
+                                if (!typeToPath.TryGetValue(child.type, out var expectedPath))
+                                    // expectedPath should be here, something was wrong with PathAndType extension
+                                    return false;
+
+                                if (childPath != expectedPath)
+                                    return false;
+                            }
+
+                            if (!Traverse(child, childPath))
+                                return false;
+                        }
+
+                        return true;
+                    }
+
+                    return Traverse(treeProvider.root, null);
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTreeProviderTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTreeProviderTests.cs.meta
new file mode 100644
index 00000000000..009b67bc1e7
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentArchetypeTreeProviderTests.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 556f63c08793467394ea78b6ac03e466
+timeCreated: 1639573764
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentDatabaseTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentDatabaseTests.cs
new file mode 100644
index 00000000000..fde3f16247f
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentDatabaseTests.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class VolumeComponentDatabaseTests
+    {
+        class VolumeComponentWithStaticInit : VolumeComponent
+        {
+            public static int initCount;
+            static void Init()
+            {
+                ++initCount;
+            }
+        }
+
+        [Test]
+        public void ContainsRequiredTypes()
+        {
+            bool Property(VolumeComponentType[] types)
+            {
+                var database = VolumeComponentDatabase.FromTypes(types);
+                using (HashSetPool<VolumeComponentType>.Get(out var set))
+                {
+                    set.UnionWith(types);
+                    return set.SetEquals(database.componentTypes);
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[]>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void HasAllComponentsInMemory()
+        {
+            var database = VolumeComponentDatabase.memoryDatabase;
+
+            var componentTypes = CoreUtils.GetAllTypesDerivedFrom<VolumeComponent>()
+                .Where(t => !t.IsAbstract).Select(VolumeComponentType.FromTypeUnsafe).ToHashSet();
+
+            Assert.True(database.componentTypes.ToHashSet().SetEquals(componentTypes));
+        }
+
+        [Test]
+        public void CallStaticInitOnComponents()
+        {
+            var initCount = VolumeComponentWithStaticInit.initCount;
+            VolumeComponentDatabase.StaticInitializeComponents(new []
+            {
+                VolumeComponentType.FromTypeUnsafe(typeof(VolumeComponentWithStaticInit))
+            });
+            Assert.AreEqual(initCount + 1, VolumeComponentWithStaticInit.initCount);
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentDatabaseTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentDatabaseTests.cs.meta
new file mode 100644
index 00000000000..2dea0bfe4ed
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentDatabaseTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7e8387c6b60531b4fa8278496c82835c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentFilterTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentFilterTests.cs
new file mode 100644
index 00000000000..38558195fbc
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentFilterTests.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Linq;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class VolumeComponentFilterTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void EverythingFilterAccepts()
+        {
+            bool Property(VolumeComponentType type)
+            {
+                var filter = new EverythingVolumeComponentFilter();
+                return filter.IsAccepted(type);
+            }
+
+            Prop.ForAll<VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void IsExplicitlySupportedFilterAccepts()
+        {
+            bool Property(VolumeComponentType subject, VolumeComponentType target)
+            {
+                var filter = IsExplicitlySupportedVolumeComponentFilter.FromType(target.AsType());
+                var isAccepted = filter.IsAccepted(subject);
+                var expected = IsSupportedOn.IsExplicitlySupportedBy(subject.AsType(), target.AsType());
+                return isAccepted == expected;
+            }
+
+            Prop.ForAll<VolumeComponentType, VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void IsSupportedFilterAccepts()
+        {
+            bool Property(VolumeComponentType subject, VolumeComponentType target)
+            {
+                var filter = IsSupportedVolumeComponentFilter.FromType(target.AsType());
+                var isAccepted = filter.IsAccepted(subject);
+                var expected = IsSupportedOn.IsSupportedBy(subject.AsType(), target.AsType());
+                return isAccepted == expected;
+            }
+
+            Prop.ForAll<VolumeComponentType, VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void IsVisibleFilterAccepts()
+        {
+            bool Property(VolumeComponentType subject, bool isVisible)
+            {
+                var filter = IsVisibleVolumeComponentFilter.FromIsVisible(isVisible);
+                var isAccepted = filter.IsAccepted(subject);
+                var isVisibleValue = IsVisibleVolumeComponentFilter.IsVisible(subject);
+                var expected = isVisible && isVisibleValue || !isVisible && !isVisibleValue;
+                return isAccepted == expected;
+            }
+
+            Prop.ForAll<VolumeComponentType, bool>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void IsVisibleIffNotObsoleteNotHideInInspector()
+        {
+            bool Property(VolumeComponentType subject)
+            {
+                var isVisible = IsVisibleVolumeComponentFilter.IsVisible(subject);
+                var expected = subject.AsType().GetCustomAttributes(true)
+                    .All(attr => attr is not ObsoleteAttribute and not HideInInspector);
+                return isVisible == expected;
+            }
+
+            Prop.ForAll<VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentFilterTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentFilterTests.cs.meta
new file mode 100644
index 00000000000..573830eb127
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentFilterTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 70cd7945037f39245bb6041f36820fcf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTests.cs
index d76b2221d75..354ec43cddd 100644
--- a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTests.cs
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTests.cs
@@ -11,14 +11,14 @@ namespace UnityEngine.Rendering.Tests
     public class VolumeComponentEditorTests
     {
         [HideInInspector]
-        [VolumeComponentMenuForRenderPipeline("Tests/No Additional", typeof(RenderPipeline))]
+        [VolumeComponentMenu("Tests/No Additional"), SupportedOn(typeof(RenderPipeline))]
         class VolumeComponentNoAdditionalAttributes : VolumeComponent
         {
             public MinFloatParameter parameter = new MinFloatParameter(0f, 0f);
         }
 
         [HideInInspector]
-        [VolumeComponentMenuForRenderPipeline("Tests/All Additional", typeof(RenderPipeline))]
+        [VolumeComponentMenu("Tests/All Additional"), SupportedOn(typeof(RenderPipeline))]
         class VolumeComponentAllAdditionalAttributes : VolumeComponent
         {
             [AdditionalProperty]
@@ -29,7 +29,7 @@ class VolumeComponentAllAdditionalAttributes : VolumeComponent
         }
 
         [HideInInspector]
-        [VolumeComponentMenuForRenderPipeline("Tests/Mixed Additional", typeof(RenderPipeline))]
+        [VolumeComponentMenu("Tests/Mixed Additional"), SupportedOn(typeof(RenderPipeline))]
         class VolumeComponentMixedAdditionalAttributes : VolumeComponent
         {
             public MinFloatParameter parameter1 = new MinFloatParameter(0f, 0f);
@@ -142,54 +142,6 @@ class VolumeComponentDecorators : VolumeComponent
             ("Size and occurrence", "Increase to make patches SMALLER, and frequent")
         };
 
-        [Test]
-        public void TestHandleParameterDecorators()
-        {
-            VolumeComponent component = null;
-            VolumeComponentEditor editor = null;
-            CreateEditorAndComponent(typeof(VolumeComponentDecorators), ref component, ref editor);
-
-            var parameters =
-                editor.GetField("m_Parameters") as List<(GUIContent displayName, int displayOrder,
-                    SerializedDataParameter param)>;
-
-            Assert.True(parameters != null && parameters.Count() == k_ExpectedResults.Count());
-
-            for (int i = 0; i < k_ExpectedResults.Count(); ++i)
-            {
-                var property = parameters[i].param;
-                var title = new GUIContent(parameters[i].displayName);
-
-                editor.Invoke("HandleDecorators", property, title);
-
-                Assert.True(k_ExpectedResults[i].displayName == title.text);
-                Assert.True(k_ExpectedResults[i].tooltip == title.tooltip);
-            }
-
-            ScriptableObject.DestroyImmediate(component);
-        }
-
-        #endregion
-
-        [Test]
-        public void TestSupportedOnAvoidedIfHideInInspector()
-        {
-            Type[] types = new[]
-            {
-                typeof(VolumeComponentNoAdditionalAttributes),
-                typeof(VolumeComponentAllAdditionalAttributes),
-                typeof(VolumeComponentMixedAdditionalAttributes)
-            };
-
-            Type volumeComponentProvider = ReflectionUtils.FindTypeByName("UnityEngine.Rendering.VolumeManager");
-            var volumeComponents = volumeComponentProvider.InvokeStatic("FilterVolumeComponentTypes",
-                types, typeof(RenderPipeline)) as List<(string, Type)>;
-
-
-            Assert.NotNull(volumeComponents);
-            Assert.False(volumeComponents.Any());
-        }
-
         static private bool TestAnimationCurveInterp(AnimationCurve lhsCurve, AnimationCurve rhsCurve, float t, float startTime, float endTime, int numSteps, float eps, bool debugPrint)
         {
             AnimationCurve midCurve = new AnimationCurve(lhsCurve.keys);
@@ -309,5 +261,34 @@ public void RenderInterpolateAnimationCurve(AnimationCurveTestPair testPairData)
             }
             Assert.IsTrue(success);
         }
+
+        [Test]
+        public void TestHandleParameterDecorators()
+        {
+            VolumeComponent component = null;
+            VolumeComponentEditor editor = null;
+            CreateEditorAndComponent(typeof(VolumeComponentDecorators), ref component, ref editor);
+
+            var parameters =
+                editor.GetField("m_Parameters") as List<(GUIContent displayName, int displayOrder,
+                    SerializedDataParameter param)>;
+
+            Assert.True(parameters != null && parameters.Count() == k_ExpectedResults.Count());
+
+            for (int i = 0; i < k_ExpectedResults.Count(); ++i)
+            {
+                var property = parameters[i].param;
+                var title = new GUIContent(parameters[i].displayName);
+
+                editor.Invoke("HandleDecorators", property, title);
+
+                Assert.True(k_ExpectedResults[i].displayName == title.text);
+                Assert.True(k_ExpectedResults[i].tooltip == title.tooltip);
+            }
+
+            ScriptableObject.DestroyImmediate(component);
+        }
+
+        #endregion
     }
 }
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTreeProviderTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTreeProviderTests.cs
new file mode 100644
index 00000000000..ec93edcef06
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTreeProviderTests.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Linq;
+using FsCheck;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEditor.Rendering;
+using UnityEngine.Tests;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class VolumeComponentTreeProviderTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void ProvidedTreeContainsAllTypeExceptAlreadyContainedInProfile()
+        {
+            bool Property(VolumeComponentType[] profileTypes, VolumeComponentArchetype treeArchetype)
+            {
+                // create volume profile
+                var profile = ScriptableObject.CreateInstance<VolumeProfile>();
+                foreach (var type in profileTypes)
+                {
+                    if (!profile.Has(type.AsType()))
+                        profile.Add(type.AsType());
+                }
+
+                // Create the editor
+                var editor = Editor.CreateEditor(profile);
+                var volumeProfileEditor = new VolumeComponentListEditor(editor);
+                var treeProvider = new VolumeComponentTreeProvider(profile, volumeProfileEditor, treeArchetype);
+
+                // Create the tree
+                using (ListPool<FilterWindow.Element>.Get(out var elements))
+                {
+                    treeProvider.CreateComponentTree(elements);
+
+                    if (!treeArchetype.GetOrAddPathAndType(out var pathAndType))
+                        return false;
+                    var expectedTypes = pathAndType.volumeComponentPathAndTypes.Select(p => p.type).Except(profileTypes).ToHashSet();
+                    var currentTypes = elements.Where(e => e is VolumeComponentTreeProvider.VolumeComponentElement)
+                        .Cast<VolumeComponentTreeProvider.VolumeComponentElement>()
+                        .Select(e => e.type)
+                        .ToHashSet();
+
+                    // Cleanup resources
+                    Object.DestroyImmediate(editor);
+                    Object.DestroyImmediate(profile);
+
+                    return expectedTypes.SetEquals(currentTypes);
+                }
+            }
+
+            Prop.ForAll<VolumeComponentType[], VolumeComponentArchetype>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTreeProviderTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTreeProviderTests.cs.meta
new file mode 100644
index 00000000000..c858f4ab771
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTreeProviderTests.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 58d246c9811b4bdbb4bee9d85e44388a
+timeCreated: 1639645383
\ No newline at end of file
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTypeTests.cs b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTypeTests.cs
new file mode 100644
index 00000000000..4f989e07e85
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTypeTests.cs
@@ -0,0 +1,45 @@
+using System;
+using FsCheck;
+using NUnit.Framework;
+using UnityEngine.Tests;
+
+namespace UnityEngine.Rendering.Tests
+{
+    class VolumeComponentTypeTests
+    {
+        [OneTimeSetUp]
+        public static void SetupFixture()
+        {
+            ArbX.Register();
+        }
+
+        [Test]
+        public void OnlyAcceptsVolumeComponentTypes()
+        {
+            bool Property(Type type)
+            {
+                var success = VolumeComponentType.FromType(type, out var volumeType);
+                var isVolumeType = type?.IsSubclassOf(typeof(VolumeComponent));
+
+                var mustBeValid = isVolumeType == true;
+                var isValid = success && volumeType.AsType() == type;
+                var isInvalid = !success && volumeType == default;
+
+                return mustBeValid && isValid || !mustBeValid && isInvalid;
+            }
+
+            Prop.ForAll(ArbX.CreateTypeArbitrary(), Property).ContextualQuickCheckThrowOnFailure();
+        }
+
+        [Test]
+        public void CastToType()
+        {
+            bool Property(VolumeComponentType type)
+            {
+                return type.AsType() == (Type)type;
+            }
+
+            Prop.ForAll<VolumeComponentType>(Property).ContextualQuickCheckThrowOnFailure();
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTypeTests.cs.meta b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTypeTests.cs.meta
new file mode 100644
index 00000000000..243964b9821
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Editor/Volumes/VolumeComponentTypeTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9864e65d545d07d45a99cd703e1d9aff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.render-pipelines.core/Tests/Runtime/IsSupportedOn.cs b/com.unity.render-pipelines.core/Tests/Runtime/IsSupportedOn.cs
new file mode 100644
index 00000000000..84ccc1b0b8a
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Runtime/IsSupportedOn.cs
@@ -0,0 +1,43 @@
+using NUnit.Framework;
+
+namespace UnityEngine.Rendering.Tests
+{
+    [SupportedOn(typeof(__B))]
+    class __A { }
+    class __B { }
+    class __C { }
+
+
+    public class IsSupportedOnTest
+    {
+        [Test]
+        public void GenericAPI()
+        {
+            Assert.True(IsSupportedOn.HasExplicitSupport<__A>(), "A has explicit support.");
+            Assert.False(IsSupportedOn.HasExplicitSupport<__B>(), "B has no explicit support.");
+
+            Assert.True(IsSupportedOn.IsExplicitlySupportedBy<__A, __B>(), "A supports explicitly B.");
+            Assert.True(IsSupportedOn.IsSupportedBy<__A, __B>(), "A supports B.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy<__A, __C>(), "A don't supports explicitly B.");
+            Assert.False(IsSupportedOn.IsSupportedBy<__A, __C>(), "A don't supports implicitly B.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy<__B, __C>(), "B don't supports explicitly C.");
+            Assert.True(IsSupportedOn.IsSupportedBy<__B, __C>(), "B supports implicitly C.");
+        }
+
+        [Test]
+        public void DynamicAPI()
+        {
+            Assert.True(IsSupportedOn.IsExplicitlySupportedBy(typeof(__A), typeof(__B)), "A supports explicitly B.");
+            Assert.True(IsSupportedOn.IsSupportedBy(typeof(__A), typeof(__B)), "A supports B.");
+            Assert.True(IsSupportedOn.HasExplicitSupport(typeof(__A)), "A has explicit support.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy(typeof(__A), typeof(__C)), "A don't supports explicitly B.");
+            Assert.False(IsSupportedOn.IsSupportedBy(typeof(__A), typeof(__C)), "A don't supports implicitly B.");
+
+            Assert.False(IsSupportedOn.IsExplicitlySupportedBy(typeof(__B), typeof(__C)), "B don't supports explicitly C.");
+            Assert.True(IsSupportedOn.IsSupportedBy(typeof(__B), typeof(__C)), "B supports implicitly C.");
+        }
+    }
+}
diff --git a/com.unity.render-pipelines.core/Tests/Runtime/IsSupportedOn.cs.meta b/com.unity.render-pipelines.core/Tests/Runtime/IsSupportedOn.cs.meta
new file mode 100644
index 00000000000..dc762b28668
--- /dev/null
+++ b/com.unity.render-pipelines.core/Tests/Runtime/IsSupportedOn.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9613aaf8a9d4e3caec64864d3f8c440
+timeCreated: 1633684187
\ No newline at end of file
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Compositor/AlphaInjection.cs b/com.unity.render-pipelines.high-definition/Runtime/Compositor/AlphaInjection.cs
index 710fceffc2a..064621c8ce7 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Compositor/AlphaInjection.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Compositor/AlphaInjection.cs
@@ -7,7 +7,7 @@ namespace UnityEngine.Rendering.HighDefinition.Compositor
 {
     // Injects an external alpha texture into the alpha channel. Used for controlling which pixels will be affected by post processing.
     // Use VolumeComponentDeprecated to hide the component from the volume menu (it's for internal compositor use only)
-    [Serializable, HideInInspector]
+    [Serializable, HideInInspector, SupportedOn(typeof(HDRenderPipeline))]
     internal sealed class AlphaInjection : CustomPostProcessVolumeComponent, IPostProcessComponent
     {
         internal class ShaderIDs
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Compositor/ChromaKeying.cs b/com.unity.render-pipelines.high-definition/Runtime/Compositor/ChromaKeying.cs
index fcd96202cc1..3eeb06fb812 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Compositor/ChromaKeying.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Compositor/ChromaKeying.cs
@@ -8,7 +8,7 @@ namespace UnityEngine.Rendering.HighDefinition.Compositor
     // Custom post-processing pass that performs chroma keying
     // Shader adapted from: https://github.com/keijiro/ProcAmp
     // Use HideInInspector to hide the component from the volume menu (it's for internal use only)
-    [Serializable, HideInInspector]
+    [Serializable, HideInInspector, SupportedOn(typeof(HDRenderPipeline))]
     internal sealed class ChromaKeying : CustomPostProcessVolumeComponent, IPostProcessComponent
     {
         internal class ShaderIDs
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs b/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs
index c488e6850aa..1239c64bb47 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs
@@ -30,6 +30,7 @@ unsafe struct ShaderVariablesDebugDisplay
         public int _ColorPickerMode; // Match enum ColorPickerDebugMode
 
         public Vector4 _DebugViewportSize; //Frame viewport size used during rendering.
+
         public Vector4 _DebugLightingAlbedo; // x == bool override, yzw = albedo for diffuse
         public Vector4 _DebugLightingSmoothness; // x == bool override, y == override value
         public Vector4 _DebugLightingNormal; // x == bool override
@@ -313,6 +314,7 @@ public partial class DebugData
             public bool countRays = false;
             /// <summary>Display Show Lens Flare Data Driven Only.</summary>
             public bool showLensFlareDataDrivenOnly = false;
+
             /// <summary>Index of the camera to freeze for visibility.</summary>
             public int debugCameraToFreeze = 0;
             internal RTASDebugView rtasDebugView = RTASDebugView.Shadows;
@@ -851,7 +853,6 @@ internal void SetHDRDebugMode(HDRDebugMode value)
             data.lightingDebugSettings.hdrDebugMode = value;
         }
 
-
         /// <summary>
         /// Set the current Mip Map Debug Mode.
         /// </summary>
@@ -993,11 +994,11 @@ DebugUI.Value CreateWidgetForSampler(HDProfileId samplerId, ProfilingSampler sam
                 {
                     displayName = sampler.name,
                     values = new[]
-                {
+                    {
                         CreateWidgetForSampler(samplerId, sampler, DebugProfilingType.CPU),
                         CreateWidgetForSampler(samplerId, sampler, DebugProfilingType.InlineCPU),
                         CreateWidgetForSampler(samplerId, sampler, DebugProfilingType.GPU),
-                }
+                    }
                 });
             }
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Debug/HDVolumeDebugSettings.cs b/com.unity.render-pipelines.high-definition/Runtime/Debug/HDVolumeDebugSettings.cs
index 655cce940a5..e1da2ecab71 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Debug/HDVolumeDebugSettings.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Debug/HDVolumeDebugSettings.cs
@@ -1,5 +1,4 @@
 using System;
-
 namespace UnityEngine.Rendering.HighDefinition
 {
     /// <summary>
@@ -11,6 +10,9 @@ public class HDVolumeDebugSettings : VolumeDebugSettings<HDAdditionalCameraData>
         /// Specifies the render pipeline for this volume settings
         /// </summary>
         public override Type targetRenderPipeline => typeof(HDRenderPipeline);
+        static VolumeStack s_DefaultStack = VolumeStack.FromArchetype(HDUtils.hdVolumeArchetype);
+
+        public override VolumeComponentArchetype archetype => HDUtils.hdVolumeArchetype;
 
         /// <summary>Selected camera volume stack.</summary>
         public override VolumeStack selectedCameraVolumeStack
@@ -23,7 +25,7 @@ public override VolumeStack selectedCameraVolumeStack
                 var stack = HDCamera.GetOrCreate(cam).volumeStack;
                 if (stack != null)
                     return stack;
-                return VolumeManager.instance.stack;
+                return s_DefaultStack;
             }
         }
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/AtmosphericScattering.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/AtmosphericScattering.cs
index e3fd5c85d7e..c1394aa6919 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/AtmosphericScattering.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/AtmosphericScattering.cs
@@ -4,6 +4,7 @@
 namespace UnityEngine.Rendering.HighDefinition
 {
     // Deprecated, kept for migration
+    [SupportedOn(typeof(HDRenderPipeline))]
     abstract class AtmosphericScattering : VolumeComponent
     {
         // Fog Color
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/ExponentialFog.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/ExponentialFog.cs
index 4d0e3fc1364..cac6cab8e3c 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/ExponentialFog.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/ExponentialFog.cs
@@ -3,7 +3,7 @@
 namespace UnityEngine.Rendering.HighDefinition
 {
     // Deprecated, kept for migration
-    [Obsolete()]
+    [Obsolete(), SupportedOn(typeof(HDRenderPipeline))]
     class ExponentialFog : AtmosphericScattering
     {
         private readonly static int m_ExpFogParam = Shader.PropertyToID("_ExpFogParameters");
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/Fog.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/Fog.cs
index c59623bf742..7286185709d 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/Fog.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/Fog.cs
@@ -7,7 +7,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// Fog Volume Component.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Fog", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Fog"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Fog")]
     public class Fog : VolumeComponentWithQuality
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/VolumetricFog.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/VolumetricFog.cs
index 108b67aa592..d15d758b135 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/VolumetricFog.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/AtmosphericScattering/VolumetricFog.cs
@@ -3,7 +3,7 @@
 namespace UnityEngine.Rendering.HighDefinition
 {
     // Deprecated, kept for migration
-    [Obsolete()]
+    [Obsolete(), SupportedOn(typeof(HDRenderPipeline))]
     class VolumetricFog : AtmosphericScattering
     {
         public ColorParameter albedo = new ColorParameter(Color.white);
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/DiffusionProfileOverride.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/DiffusionProfileOverride.cs
index c5e7b12b674..8cbd0cf5295 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/DiffusionProfileOverride.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/DiffusionProfileOverride.cs
@@ -2,7 +2,7 @@
 
 namespace UnityEngine.Rendering.HighDefinition
 {
-    [Serializable, VolumeComponentMenuForRenderPipeline("Material/Diffusion Profile Override", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Material/Diffusion Profile Override"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Diffusion-Profile")]
     sealed class DiffusionProfileOverride : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/GlobalIllumination.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/GlobalIllumination.cs
index f36c153e151..94437eafc24 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/GlobalIllumination.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/GlobalIllumination.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the global illumination (screen space and ray traced).
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Lighting/Screen Space Global Illumination", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Lighting/Screen Space Global Illumination"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Ray-Traced-Global-Illumination")]
     public sealed class GlobalIllumination : VolumeComponentWithQuality
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/IndirectLightingController.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/IndirectLightingController.cs
index c1fd87a6a7c..0cbb8f8addd 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/IndirectLightingController.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/IndirectLightingController.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// Component that allow you to control the indirect specular and diffuse intensity
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Lighting/Indirect Lighting Controller", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Lighting/Indirect Lighting Controller"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Indirect-Lighting-Controller")]
     public class IndirectLightingController : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumesOptions.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumesOptions.cs
index 501fc8fa88b..5971e91c655 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumesOptions.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumesOptions.cs
@@ -22,7 +22,7 @@ public APVLeakReductionModeParameter(APVLeakReductionMode value, bool overrideSt
     /// <summary>
     /// A volume component that holds settings for the Probe Volumes System per-camera options.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Lighting/Probe Volumes Options (Experimental)", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Lighting/Probe Volumes Options (Experimental)"), SupportedOn(typeof(HDRenderPipeline))]
     public sealed class ProbeVolumesOptions : VolumeComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/AmbientOcclusion.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/AmbientOcclusion.cs
index 11ba2546db6..7e7be83faa9 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/AmbientOcclusion.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/AmbientOcclusion.cs
@@ -8,7 +8,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the ambient occlusion.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Lighting/Ambient Occlusion", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Lighting/Ambient Occlusion"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Ambient-Occlusion")]
     public sealed class AmbientOcclusion : VolumeComponentWithQuality
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflection.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflection.cs
index b2251110c7b..1cf354f16b0 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflection.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceReflection.cs
@@ -33,7 +33,7 @@ public SSRAlgoParameter(ScreenSpaceReflectionAlgorithm value, bool overrideState
     /// <summary>
     /// A volume component that holds settings for screen space reflection and ray traced reflections.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Lighting/Screen Space Reflection", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Lighting/Screen Space Reflection"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Screen-Space-Reflection")]
     public class ScreenSpaceReflection : VolumeComponentWithQuality
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceRefraction.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceRefraction.cs
index f4ad411ef77..d36b00620dd 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceRefraction.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ScreenSpaceRefraction.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Screen Space Refraction effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Lighting/Screen Space Refraction", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Lighting/Screen Space Refraction"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Screen-Space-Refraction")]
     public class ScreenSpaceRefraction : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/ContactShadows.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/ContactShadows.cs
index 8f4562cc0d7..e627821f24e 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/ContactShadows.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/ContactShadows.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Contact Shadows effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Shadowing/Contact Shadows", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Shadowing/Contact Shadows"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Contact-Shadows")]
     public class ContactShadows : VolumeComponentWithQuality
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/HDShadowSettings.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/HDShadowSettings.cs
index 6c21c338774..e6eeb2d803f 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/HDShadowSettings.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/HDShadowSettings.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// Settings for shadows.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Shadowing/Shadows", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Shadowing/Shadows"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Shadows")]
     public class HDShadowSettings : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/MicroShadowing.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/MicroShadowing.cs
index ccaf66fe861..661bd9bb2ff 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/MicroShadowing.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Shadow/MicroShadowing.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Micro Shadows effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Shadowing/Micro Shadows", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Shadowing/Micro Shadows"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Micro-Shadows")]
     public class MicroShadowing : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricClouds.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricClouds.cs
index e09bd1f85ed..70b19e4f23a 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricClouds.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricClouds.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the ambient occlusion.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Sky/Volumetric Clouds", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Sky/Volumetric Clouds"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Volumetric-Clouds")]
     public sealed partial class VolumetricClouds : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricLightingController.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricLightingController.cs
index 35fc797ec2e..189e5b30695 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricLightingController.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Lighting/VolumetricLighting/VolumetricLightingController.cs
@@ -3,7 +3,7 @@
 
 namespace UnityEngine.Rendering.HighDefinition
 {
-    [Obsolete()]
+    [Obsolete(), SupportedOn(typeof(HDRenderPipeline))]
     class VolumetricLightingController : VolumeComponent
     {
         [Tooltip("Sets the distance (in meters) from the Camera's Near Clipping Plane to the back of the Camera's volumetric lighting buffer.")]
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Material/SubsurfaceScattering/SubSurfaceScattering.cs b/com.unity.render-pipelines.high-definition/Runtime/Material/SubsurfaceScattering/SubSurfaceScattering.cs
index dad9db99f6e..5778e105164 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Material/SubsurfaceScattering/SubSurfaceScattering.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Material/SubsurfaceScattering/SubSurfaceScattering.cs
@@ -7,7 +7,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// This component setups subsurface scattering for ray-tracing.
     /// </summary>
     [HDRPHelpURLAttribute("Ray-Traced-Subsurface-Scattering")]
-    [Serializable, VolumeComponentMenuForRenderPipeline("Ray Tracing/SubSurface Scattering (Preview)", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Ray Tracing/SubSurface Scattering (Preview)"), SupportedOn(typeof(HDRenderPipeline))]
     public sealed class SubSurfaceScattering : VolumeComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Bloom.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Bloom.cs
index 1b48f719dee..6a856ad58d7 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Bloom.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Bloom.cs
@@ -24,7 +24,7 @@ public enum BloomResolution : int
     /// <summary>
     /// A volume component that holds settings for the Bloom effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Bloom", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Bloom"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Bloom")]
     public sealed class Bloom : VolumeComponentWithQuality, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChannelMixer.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChannelMixer.cs
index c77d660586a..63d5e008d8a 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChannelMixer.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChannelMixer.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Channel Mixer effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Channel Mixer", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Channel Mixer"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Channel-Mixer")]
     public sealed class ChannelMixer : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChromaticAberration.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChromaticAberration.cs
index 8313e501a5a..9774c2afaaa 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChromaticAberration.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ChromaticAberration.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Chromatic Aberration effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Chromatic Aberration", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Chromatic Aberration"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Chromatic-Aberration")]
 
     public sealed class ChromaticAberration : VolumeComponentWithQuality, IPostProcessComponent
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorAdjustments.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorAdjustments.cs
index 64df48a9eaf..709de86b204 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorAdjustments.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorAdjustments.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Color Adjustments effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Color Adjustments", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Color Adjustments"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Color-Adjustments")]
     public sealed class ColorAdjustments : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorCurves.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorCurves.cs
index 372758bda9a..70534bc91d6 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorCurves.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ColorCurves.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Color Adjustments effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Color Curves", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Color Curves"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Color-Curves")]
     public sealed class ColorCurves : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/DepthOfField.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/DepthOfField.cs
index ec796d3286f..7123d76e0b1 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/DepthOfField.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/DepthOfField.cs
@@ -68,7 +68,7 @@ public enum FocusDistanceMode
     /// <summary>
     /// A volume component that holds settings for the Depth Of Field effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Depth Of Field", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Depth Of Field"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Depth-of-Field")]
     public sealed class DepthOfField : VolumeComponentWithQuality, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Exposure.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Exposure.cs
index 139d41686b9..1123864f5bc 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Exposure.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Exposure.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Exposure effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Exposure", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Exposure"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Exposure")]
     public sealed class Exposure : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/FilmGrain.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/FilmGrain.cs
index 5516c19c484..1a48547ca15 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/FilmGrain.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/FilmGrain.cs
@@ -68,7 +68,7 @@ public enum FilmGrainLookup
     /// <summary>
     /// A volume component that holds settings for the Film Grain effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Film Grain", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Film Grain"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Film-Grain")]
     public sealed class FilmGrain : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LensDistortion.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LensDistortion.cs
index 429fe113f80..5568a68a383 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LensDistortion.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LensDistortion.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Lens Distortion effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Lens Distortion", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Lens Distortion"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Lens-Distortion")]
     public sealed class LensDistortion : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LiftGammaGain.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LiftGammaGain.cs
index 923e23c712a..01f7dc77c24 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LiftGammaGain.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/LiftGammaGain.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Lift, Gamma, Gain effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Lift, Gamma, Gain", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Lift, Gamma, Gain"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Lift-Gamma-Gain")]
     public sealed class LiftGammaGain : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/MotionBlur.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/MotionBlur.cs
index b08e6284d8c..8cf4827767c 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/MotionBlur.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/MotionBlur.cs
@@ -51,7 +51,7 @@ public CameraClampModeParameter(CameraClampMode value, bool overrideState = fals
     /// <summary>
     /// A volume component that holds settings for the Motion Blur effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Motion Blur", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Motion Blur"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Motion-Blur")]
     public sealed class MotionBlur : VolumeComponentWithQuality, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/PaniniProjection.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/PaniniProjection.cs
index 3433a63a319..5e5ea59f2ce 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/PaniniProjection.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/PaniniProjection.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Panini Projection effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Panini Projection", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Panini Projection"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Panini-Projection")]
     public sealed class PaniniProjection : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ShadowsMidtonesHighlights.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ShadowsMidtonesHighlights.cs
index e720db1eff1..4cea1b3cbc1 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ShadowsMidtonesHighlights.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/ShadowsMidtonesHighlights.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Shadows, Midtones, Highlights effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Shadows, Midtones, Highlights", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Shadows, Midtones, Highlights"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Shadows-Midtones-Highlights")]
     public sealed class ShadowsMidtonesHighlights : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/SplitToning.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/SplitToning.cs
index 63d370f280e..43853c322de 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/SplitToning.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/SplitToning.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the Split Toning effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Split Toning", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Split Toning"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Split-Toning")]
     public sealed class SplitToning : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Tonemapping.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Tonemapping.cs
index 2f7bf5ef176..8e947f4eaa3 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Tonemapping.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Tonemapping.cs
@@ -135,7 +135,7 @@ public FallbackHDRTonemapParameter(FallbackHDRTonemap value, bool overrideState
     /// <summary>
     /// A volume component that holds settings for the Tonemapping effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Tonemapping", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Tonemapping"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Tonemapping")]
     public sealed class Tonemapping : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Vignette.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Vignette.cs
index 4594a407f64..7bf888af742 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Vignette.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/Vignette.cs
@@ -22,7 +22,7 @@ public enum VignetteMode
     /// <summary>
     /// A volume component that holds settings for the Vignette effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Vignette", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Vignette"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-Vignette")]
     public sealed class Vignette : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/WhiteBalance.cs b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/WhiteBalance.cs
index ec770bf9f1e..4de2b456081 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/WhiteBalance.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Components/WhiteBalance.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the White Balance effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/White Balance", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/White Balance"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Post-Processing-White-Balance")]
     public sealed class WhiteBalance : VolumeComponent, IPostProcessComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Camera/HDCamera.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Camera/HDCamera.cs
index ef817e9b126..b32e026c2f8 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Camera/HDCamera.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Camera/HDCamera.cs
@@ -710,7 +710,7 @@ internal HDCamera(Camera cam)
 
             frustumPlaneEquations = new Vector4[6];
 
-            volumeStack = VolumeManager.instance.CreateStack();
+            volumeStack = VolumeStack.FromArchetype(HDUtils.hdVolumeArchetype);
 
             m_DepthBufferMipChainInfo.Allocate();
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/PathTracing.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/PathTracing.cs
index 52c03fad821..ac9abdc9499 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/PathTracing.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/PathTracing.cs
@@ -46,7 +46,7 @@ public SkyImportanceSamplingParameter(SkyImportanceSamplingMode value, bool over
     /// <summary>
     /// A volume component that holds settings for the Path Tracing effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Ray Tracing/Path Tracing (Preview)", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Ray Tracing/Path Tracing (Preview)"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Ray-Tracing-Path-Tracing")]
     public sealed class PathTracing : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/LightCluster.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/LightCluster.cs
index 0fb7dc496f5..1c80bb53232 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/LightCluster.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/LightCluster.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// <summary>
     /// A volume component that holds settings for the ray tracing light cluster.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Ray Tracing/Light Cluster (Preview)", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Ray Tracing/Light Cluster (Preview)"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Ray-Tracing-Light-Cluster")]
     public sealed class LightCluster : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RayTracingSettings.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RayTracingSettings.cs
index c0e7bae3c2c..a5dc4995f06 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RayTracingSettings.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RayTracingSettings.cs
@@ -59,7 +59,7 @@ public RTASCullingModeParameter(RTASCullingMode value, bool overrideState = fals
     /// A volume component that holds the general settings for ray traced effects.
     /// </summary>
     [HDRPHelpURLAttribute("Ray-Tracing-Settings")]
-    [Serializable, VolumeComponentMenuForRenderPipeline("Ray Tracing/Ray Tracing Settings (Preview)", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Ray Tracing/Ray Tracing Settings (Preview)"), SupportedOn(typeof(HDRenderPipeline))]
     public sealed class RayTracingSettings : VolumeComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RecursiveRendering.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RecursiveRendering.cs
index f03f62d98b2..43bc67eb4b3 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RecursiveRendering.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/RecursiveRendering.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// Recursive Rendering Volume Component.
     /// This component setups recursive rendering.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Ray Tracing/Recursive Rendering (Preview)", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Ray Tracing/Recursive Rendering (Preview)"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Ray-Tracing-Recursive-Rendering")]
     public sealed class RecursiveRendering : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Utility/HDUtils.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Utility/HDUtils.cs
index 3027496908a..ea8d2a22ae0 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Utility/HDUtils.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Utility/HDUtils.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using UnityEngine.Experimental.Rendering;
 using System.Text.RegularExpressions;
@@ -57,6 +58,9 @@ public static Texture3D clearTexture3D
             }
         }
 
+        [NotNull]
+        internal static VolumeComponentArchetype hdVolumeArchetype { get; } = VolumeComponentArchetype.FromFilterCached(IsExplicitlySupportedVolumeComponentFilter.FromType(typeof(HDRenderPipeline)));
+
         /// <summary>
         /// Default 1x1x1 3D RTHandle initialized with Color.clear.
         /// </summary>
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Sky/CloudSystem/CloudLayer/CloudLayer.cs b/com.unity.render-pipelines.high-definition/Runtime/Sky/CloudSystem/CloudLayer/CloudLayer.cs
index fe021a05501..5234e0dac7c 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Sky/CloudSystem/CloudLayer/CloudLayer.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Sky/CloudSystem/CloudLayer/CloudLayer.cs
@@ -82,7 +82,7 @@ public CloudLayerEnumParameter(T value, bool overrideState = false)
     /// Cloud Layer Volume Component.
     /// This component setups the Cloud Layer for rendering.
     /// </summary>
-    [VolumeComponentMenuForRenderPipeline("Sky/Cloud Layer", typeof(HDRenderPipeline))]
+    [VolumeComponentMenu("Sky/Cloud Layer"), SupportedOn(typeof(HDRenderPipeline))]
     [CloudUniqueID((int)CloudType.CloudLayer)]
     [HDRPHelpURLAttribute("Override-Cloud-Layer")]
     public class CloudLayer : CloudSettings
@@ -330,13 +330,14 @@ public override int GetHashCode()
         /// <returns>CloudLayerRenderer type.</returns>
         public override Type GetCloudRendererType() { return typeof(CloudLayerRenderer); }
 
-        /// <summary>
-        /// Called though reflection by the VolumeManager.
-        /// </summary>
-        static void Init()
+        [RuntimeInitializeOnLoadMethod]
+#if UNITY_EDITOR
+        [UnityEditor.InitializeOnLoadMethod]
+#endif
+        static void InitVolume()
         {
             var globalSettings = HDRenderPipelineGlobalSettings.instance;
-            if (globalSettings != null)
+            if (globalSettings != null && CloudMap.s_DefaultTexture == null)
                 CloudMap.s_DefaultTexture = globalSettings.renderPipelineResources?.textures.defaultCloudMap;
         }
     }
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Sky/GradientSky/GradientSky.cs b/com.unity.render-pipelines.high-definition/Runtime/Sky/GradientSky/GradientSky.cs
index 3ae12e6657a..3afc7e2b72d 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Sky/GradientSky/GradientSky.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Sky/GradientSky/GradientSky.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// Gradient Sky Volume Component.
     /// This component setups gradient sky for rendering.
     /// </summary>
-    [VolumeComponentMenuForRenderPipeline("Sky/Gradient Sky", typeof(HDRenderPipeline))]
+    [VolumeComponentMenu("Sky/Gradient Sky"), SupportedOn(typeof(HDRenderPipeline))]
     [SkyUniqueID((int)SkyType.Gradient)]
     [HDRPHelpURLAttribute("Override-Gradient-Sky")]
     public class GradientSky : SkySettings
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Sky/HDRISky/HDRISky.cs b/com.unity.render-pipelines.high-definition/Runtime/Sky/HDRISky/HDRISky.cs
index f2704227e30..545e3ca0704 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Sky/HDRISky/HDRISky.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Sky/HDRISky/HDRISky.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// HDRI Sky Volume Component.
     /// This component setups HDRI sky for rendering.
     /// </summary>
-    [VolumeComponentMenuForRenderPipeline("Sky/HDRI Sky", typeof(HDRenderPipeline))]
+    [VolumeComponentMenu("Sky/HDRI Sky"), SupportedOn(typeof(HDRenderPipeline))]
     [SkyUniqueID((int)SkyType.HDRI)]
     [HDRPHelpURLAttribute("Override-HDRI-Sky")]
     public partial class HDRISky : SkySettings
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Sky/PhysicallyBasedSky/PhysicallyBasedSky.cs b/com.unity.render-pipelines.high-definition/Runtime/Sky/PhysicallyBasedSky/PhysicallyBasedSky.cs
index 616e13df028..4c3f1ee2159 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Sky/PhysicallyBasedSky/PhysicallyBasedSky.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Sky/PhysicallyBasedSky/PhysicallyBasedSky.cs
@@ -34,7 +34,7 @@ public PhysicallyBasedSkyModelParameter(PhysicallyBasedSkyModel value, bool over
     /// <summary>
     /// Physically Based Sky Volume Component.
     /// </summary>
-    [VolumeComponentMenuForRenderPipeline("Sky/Physically Based Sky", typeof(HDRenderPipeline))]
+    [VolumeComponentMenu("Sky/Physically Based Sky"), SupportedOn(typeof(HDRenderPipeline))]
     [SkyUniqueID((int)SkyType.PhysicallyBased)]
     [HDRPHelpURLAttribute("Override-Physically-Based-Sky")]
     public partial class PhysicallyBasedSky : SkySettings
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Sky/SkyManager.cs b/com.unity.render-pipelines.high-definition/Runtime/Sky/SkyManager.cs
index 3f9db1ff63f..a623398df3b 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Sky/SkyManager.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Sky/SkyManager.cs
@@ -388,7 +388,7 @@ public void Build(HDRenderPipelineAsset hdAsset, HDRenderPipelineRuntimeResource
             m_ComputeAmbientProbeVolumetricKernel = m_ComputeAmbientProbeCS.FindKernel("AmbientProbeConvolutionDiffuseVolumetric");
             m_ComputeAmbientProbeCloudsKernel = m_ComputeAmbientProbeCS.FindKernel("AmbientProbeConvolutionClouds");
 
-            lightingOverrideVolumeStack = VolumeManager.instance.CreateStack();
+            lightingOverrideVolumeStack = VolumeStack.FromArchetype(HDUtils.hdVolumeArchetype);
             lightingOverrideLayerMask = hdAsset.currentPlatformRenderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask;
 
             m_CubemapScreenSize = new Vector4((float)m_Resolution, (float)m_Resolution, 1.0f / (float)m_Resolution, 1.0f / (float)m_Resolution);
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Sky/VisualEnvironment.cs b/com.unity.render-pipelines.high-definition/Runtime/Sky/VisualEnvironment.cs
index d369fc25f95..d54ed63a5f7 100644
--- a/com.unity.render-pipelines.high-definition/Runtime/Sky/VisualEnvironment.cs
+++ b/com.unity.render-pipelines.high-definition/Runtime/Sky/VisualEnvironment.cs
@@ -7,7 +7,7 @@ namespace UnityEngine.Rendering.HighDefinition
     /// Visual Environment Volume Component.
     /// This component setups the sky used for rendering as well as the way ambient probe should be computed.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Visual Environment", typeof(HDRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Visual Environment"), SupportedOn(typeof(HDRenderPipeline))]
     [HDRPHelpURLAttribute("Override-Visual-Environment")]
     public sealed class VisualEnvironment : VolumeComponent
     {
diff --git a/com.unity.render-pipelines.universal/Runtime/Debug/UniversalRenderPipelineVolumeDebugSettings.cs b/com.unity.render-pipelines.universal/Runtime/Debug/UniversalRenderPipelineVolumeDebugSettings.cs
index 6ec22b32a55..c26ff9d878c 100644
--- a/com.unity.render-pipelines.universal/Runtime/Debug/UniversalRenderPipelineVolumeDebugSettings.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Debug/UniversalRenderPipelineVolumeDebugSettings.cs
@@ -7,6 +7,8 @@ namespace UnityEngine.Rendering.Universal
     /// </summary>
     public class UniversalRenderPipelineVolumeDebugSettings : VolumeDebugSettings<UniversalAdditionalCameraData>
     {
+        public override VolumeComponentArchetype archetype => RenderingUtils.volumeArchetype;
+
         /// <summary>
         /// Specifies the render pipeline for this volume settings
         /// </summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/Bloom.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/Bloom.cs
index 0e32a135c3e..a36017bb32d 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/Bloom.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/Bloom.cs
@@ -14,7 +14,7 @@ public enum BloomDownscaleMode
     /// <summary>
     /// A volume component that holds settings for the Bloom effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Bloom", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Bloom"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed partial class Bloom : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/ChannelMixer.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/ChannelMixer.cs
index 501c2938ba6..49bb2400287 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/ChannelMixer.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/ChannelMixer.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Channel Mixer effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Channel Mixer", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Channel Mixer"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class ChannelMixer : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/ChromaticAberration.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/ChromaticAberration.cs
index dd84345262e..f763b4e95d5 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/ChromaticAberration.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/ChromaticAberration.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Chromatic Aberration effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Chromatic Aberration", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Chromatic Aberration"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class ChromaticAberration : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/ColorAdjustments.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/ColorAdjustments.cs
index 9b119df0473..586b30c653b 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/ColorAdjustments.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/ColorAdjustments.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Color Adjustments effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Color Adjustments", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Color Adjustments"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class ColorAdjustments : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/ColorCurves.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/ColorCurves.cs
index 73d1f2211f9..aefd1e0647e 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/ColorCurves.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/ColorCurves.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Color Adjustments effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Color Curves", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Color Curves"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class ColorCurves : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/ColorLookup.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/ColorLookup.cs
index b4b1ffcdaf5..9d418f764c3 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/ColorLookup.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/ColorLookup.cs
@@ -6,7 +6,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the color lookup effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Color Lookup", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Color Lookup"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class ColorLookup : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/DepthOfField.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/DepthOfField.cs
index a1cf4b8686b..cb1dcd622d4 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/DepthOfField.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/DepthOfField.cs
@@ -26,7 +26,7 @@ public enum DepthOfFieldMode
     /// <summary>
     /// A volume component that holds settings for the Depth Of Field effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Depth Of Field", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Depth Of Field"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class DepthOfField : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
@@ -114,11 +114,11 @@ public bool IsActive()
     [Serializable]
     public sealed class DepthOfFieldModeParameter : VolumeParameter<DepthOfFieldMode>
     {
-        /// <summary>
-        /// Creates a new <see cref="DepthOfFieldModeParameter"/> instance.
-        /// </summary>
-        /// <param name="value">The initial value to store in the parameter.</param>
-        /// <param name="overrideState">The initial override state for the parameter.</param>
-        public DepthOfFieldModeParameter(DepthOfFieldMode value, bool overrideState = false) : base(value, overrideState) { }
+/// <summary>
+/// Creates a new <see cref="DepthOfFieldModeParameter"/> instance.
+/// </summary>
+/// <param name="value">The initial value to store in the parameter.</param>
+/// <param name="overrideState">The initial override state for the parameter.</param>
+public DepthOfFieldModeParameter(DepthOfFieldMode value, bool overrideState = false) : base(value, overrideState) { }
     }
 }
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/FilmGrain.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/FilmGrain.cs
index 4c8f73791bb..eac035c7d5b 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/FilmGrain.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/FilmGrain.cs
@@ -67,7 +67,7 @@ public enum FilmGrainLookup
     /// <summary>
     /// A volume component that holds settings for the Film Grain effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Film Grain", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Film Grain"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class FilmGrain : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
@@ -107,11 +107,11 @@ public sealed class FilmGrain : VolumeComponent, IPostProcessComponent
     [Serializable]
     public sealed class FilmGrainLookupParameter : VolumeParameter<FilmGrainLookup>
     {
-        /// <summary>
-        /// Creates a new <see cref="FilmGrainLookupParameter"/> instance.
-        /// </summary>
-        /// <param name="value">The initial value to store in the parameter.</param>
-        /// <param name="overrideState">The initial override state for the parameter.</param>
-        public FilmGrainLookupParameter(FilmGrainLookup value, bool overrideState = false) : base(value, overrideState) { }
+/// <summary>
+/// Creates a new <see cref="FilmGrainLookupParameter"/> instance.
+/// </summary>
+/// <param name="value">The initial value to store in the parameter.</param>
+/// <param name="overrideState">The initial override state for the parameter.</param>
+public FilmGrainLookupParameter(FilmGrainLookup value, bool overrideState = false) : base(value, overrideState) { }
     }
 }
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/LensDistortion.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/LensDistortion.cs
index cca0061cb95..b1485fbab1c 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/LensDistortion.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/LensDistortion.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Lens Distortion effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Lens Distortion", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Lens Distortion"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class LensDistortion : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/LiftGammaGain.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/LiftGammaGain.cs
index d1bce433ec5..df268f1fb80 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/LiftGammaGain.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/LiftGammaGain.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Split Toning effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Lift, Gamma, Gain", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Lift, Gamma, Gain"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class LiftGammaGain : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/MotionBlur.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/MotionBlur.cs
index a3a670eed17..e6b8a16e2ff 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/MotionBlur.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/MotionBlur.cs
@@ -42,7 +42,7 @@ public enum MotionBlurQuality
     /// <summary>
     /// A volume component that holds settings for the motion blur effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Motion Blur", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Motion Blur"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class MotionBlur : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
@@ -83,12 +83,12 @@ public sealed class MotionBlur : VolumeComponent, IPostProcessComponent
     [Serializable]
     public sealed class MotionBlurModeParameter : VolumeParameter<MotionBlurMode>
     {
-        /// <summary>
-        /// Creates a new <see cref="MotionBlurModeParameter"/> instance.
-        /// </summary>
-        /// <param name="value">The initial value to store in the parameter.</param>
-        /// <param name="overrideState">The initial override state for the parameter.</param>
-        public MotionBlurModeParameter(MotionBlurMode value, bool overrideState = false) : base(value, overrideState) { }
+/// <summary>
+/// Creates a new <see cref="MotionBlurModeParameter"/> instance.
+/// </summary>
+/// <param name="value">The initial value to store in the parameter.</param>
+/// <param name="overrideState">The initial override state for the parameter.</param>
+public MotionBlurModeParameter(MotionBlurMode value, bool overrideState = false) : base(value, overrideState) { }
     }
 
     /// <summary>
@@ -97,11 +97,11 @@ public MotionBlurModeParameter(MotionBlurMode value, bool overrideState = false)
     [Serializable]
     public sealed class MotionBlurQualityParameter : VolumeParameter<MotionBlurQuality>
     {
-        /// <summary>
-        /// Creates a new <see cref="MotionBlurQualityParameter"/> instance.
-        /// </summary>
-        /// <param name="value">The initial value to store in the parameter.</param>
-        /// <param name="overrideState">The initial override state for the parameter.</param>
-        public MotionBlurQualityParameter(MotionBlurQuality value, bool overrideState = false) : base(value, overrideState) { }
+/// <summary>
+/// Creates a new <see cref="MotionBlurQualityParameter"/> instance.
+/// </summary>
+/// <param name="value">The initial value to store in the parameter.</param>
+/// <param name="overrideState">The initial override state for the parameter.</param>
+public MotionBlurQualityParameter(MotionBlurQuality value, bool overrideState = false) : base(value, overrideState) { }
     }
 }
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/PaniniProjection.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/PaniniProjection.cs
index 3cb28b732d2..24876b5ff21 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/PaniniProjection.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/PaniniProjection.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Panini Projection effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Panini Projection", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Panini Projection"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class PaniniProjection : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/ShadowsMidtonesHighlights.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/ShadowsMidtonesHighlights.cs
index 479316a3bdd..884a61e432d 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/ShadowsMidtonesHighlights.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/ShadowsMidtonesHighlights.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Shadows, Midtones, Highlights effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Shadows, Midtones, Highlights", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Shadows, Midtones, Highlights"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class ShadowsMidtonesHighlights : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/SplitToning.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/SplitToning.cs
index 4994896ce72..97c14845420 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/SplitToning.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/SplitToning.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Split Toning effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Split Toning", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Split Toning"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class SplitToning : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/Tonemapping.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/Tonemapping.cs
index 326ae79f87a..ba3a9cf1731 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/Tonemapping.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/Tonemapping.cs
@@ -29,7 +29,7 @@ public enum TonemappingMode
     /// <summary>
     /// A volume component that holds settings for the tonemapping effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Tonemapping", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Tonemapping"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class Tonemapping : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
@@ -51,11 +51,11 @@ public sealed class Tonemapping : VolumeComponent, IPostProcessComponent
     [Serializable]
     public sealed class TonemappingModeParameter : VolumeParameter<TonemappingMode>
     {
-        /// <summary>
-        /// Creates a new <see cref="TonemappingModeParameter"/> instance.
-        /// </summary>
-        /// <param name="value">The initial value to store in the parameter.</param>
-        /// <param name="overrideState">The initial override state for the parameter.</param>
-        public TonemappingModeParameter(TonemappingMode value, bool overrideState = false) : base(value, overrideState) { }
+/// <summary>
+/// Creates a new <see cref="TonemappingModeParameter"/> instance.
+/// </summary>
+/// <param name="value">The initial value to store in the parameter.</param>
+/// <param name="overrideState">The initial override state for the parameter.</param>
+public TonemappingModeParameter(TonemappingMode value, bool overrideState = false) : base(value, overrideState) { }
     }
 }
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/Vignette.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/Vignette.cs
index 47a5fb4895a..2bf5b770734 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/Vignette.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/Vignette.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the Vignette effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/Vignette", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/Vignette"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class Vignette : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Overrides/WhiteBalance.cs b/com.unity.render-pipelines.universal/Runtime/Overrides/WhiteBalance.cs
index 7b7eb0797a4..c364f5d9240 100644
--- a/com.unity.render-pipelines.universal/Runtime/Overrides/WhiteBalance.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Overrides/WhiteBalance.cs
@@ -5,7 +5,7 @@ namespace UnityEngine.Rendering.Universal
     /// <summary>
     /// A volume component that holds settings for the White Balance effect.
     /// </summary>
-    [Serializable, VolumeComponentMenuForRenderPipeline("Post-processing/White Balance", typeof(UniversalRenderPipeline))]
+    [Serializable, VolumeComponentMenu("Post-processing/White Balance"), SupportedOn(typeof(UniversalRenderPipeline))]
     public sealed class WhiteBalance : VolumeComponent, IPostProcessComponent
     {
         /// <summary>
diff --git a/com.unity.render-pipelines.universal/Runtime/Passes/ColorGradingLutPass.cs b/com.unity.render-pipelines.universal/Runtime/Passes/ColorGradingLutPass.cs
index d28de56df85..806e75b1a88 100644
--- a/com.unity.render-pipelines.universal/Runtime/Passes/ColorGradingLutPass.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Passes/ColorGradingLutPass.cs
@@ -100,7 +100,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
             using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.ColorGradingLUT)))
             {
                 // Fetch all color grading settings
-                var stack = VolumeManager.instance.stack;
+                var stack = UniversalRenderPipeline.currentVolumeStack;
                 var channelMixer = stack.GetComponent<ChannelMixer>();
                 var colorAdjustments = stack.GetComponent<ColorAdjustments>();
                 var curves = stack.GetComponent<ColorCurves>();
diff --git a/com.unity.render-pipelines.universal/Runtime/Passes/PostProcessPass.cs b/com.unity.render-pipelines.universal/Runtime/Passes/PostProcessPass.cs
index 7365eeab5b7..1e438b86078 100644
--- a/com.unity.render-pipelines.universal/Runtime/Passes/PostProcessPass.cs
+++ b/com.unity.render-pipelines.universal/Runtime/Passes/PostProcessPass.cs
@@ -277,7 +277,7 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
         {
             // Start by pre-fetching all builtin effect settings we need
             // Some of the color-grading settings are only used in the color grading lut pass
-            var stack = VolumeManager.instance.stack;
+            var stack = UniversalRenderPipeline.currentVolumeStack;
             m_DepthOfField = stack.GetComponent<DepthOfField>();
             m_MotionBlur = stack.GetComponent<MotionBlur>();
             m_PaniniProjection = stack.GetComponent<PaniniProjection>();
diff --git a/com.unity.render-pipelines.universal/Runtime/RenderingUtils.cs b/com.unity.render-pipelines.universal/Runtime/RenderingUtils.cs
index 968816c8bea..5296654acf3 100644
--- a/com.unity.render-pipelines.universal/Runtime/RenderingUtils.cs
+++ b/com.unity.render-pipelines.universal/Runtime/RenderingUtils.cs
@@ -10,6 +10,9 @@ namespace UnityEngine.Rendering.Universal
     /// </summary>
     public static class RenderingUtils
     {
+        internal static VolumeComponentArchetype volumeArchetype { get; }
+            = VolumeComponentArchetype.FromFilterCached(IsExplicitlySupportedVolumeComponentFilter.FromType(typeof(UniversalRenderPipeline)));
+
         static List<ShaderTagId> m_LegacyShaderPassNames = new List<ShaderTagId>
         {
             new ShaderTagId("Always"),
diff --git a/com.unity.render-pipelines.universal/Runtime/UniversalAdditionalCameraData.cs b/com.unity.render-pipelines.universal/Runtime/UniversalAdditionalCameraData.cs
index e1adc74d723..25d0a728e60 100644
--- a/com.unity.render-pipelines.universal/Runtime/UniversalAdditionalCameraData.cs
+++ b/com.unity.render-pipelines.universal/Runtime/UniversalAdditionalCameraData.cs
@@ -202,7 +202,7 @@ public static void UpdateVolumeStack(this Camera camera, UniversalAdditionalCame
             // Create stack for camera
             if (cameraData.volumeStack == null)
             {
-                cameraData.volumeStack = VolumeManager.instance.CreateStack();
+                cameraData.volumeStack = VolumeStack.FromArchetype(RenderingUtils.volumeArchetype);
             }
 
             camera.GetVolumeLayerMaskAndTrigger(cameraData, out LayerMask layerMask, out Transform trigger);
diff --git a/com.unity.render-pipelines.universal/Runtime/UniversalRenderPipeline.cs b/com.unity.render-pipelines.universal/Runtime/UniversalRenderPipeline.cs
index 4268696a3cc..5650b161eb4 100644
--- a/com.unity.render-pipelines.universal/Runtime/UniversalRenderPipeline.cs
+++ b/com.unity.render-pipelines.universal/Runtime/UniversalRenderPipeline.cs
@@ -163,6 +163,10 @@ public static int maxVisibleAdditionalLights
         // flag to keep track of depth buffer requirements by any of the cameras in the stack
         internal static bool cameraStackRequiresDepthForPostprocessing = false;
 
+        internal static VolumeStack defaultVolumeStack = VolumeStack.FromArchetype(RenderingUtils.volumeArchetype);
+        internal static VolumeStack overrideVolumeStack;
+        internal static VolumeStack currentVolumeStack => overrideVolumeStack ?? defaultVolumeStack;
+
         /// <summary>
         /// Creates a new <c>UniversalRenderPipeline</c> instance.
         /// </summary>
@@ -299,6 +303,7 @@ protected override void Render(ScriptableRenderContext renderContext, Camera[] c
             for (int i = 0; i < cameras.Length; ++i)
 #endif
             {
+                overrideVolumeStack = null;
                 var camera = cameras[i];
                 if (IsGameCamera(camera))
                 {
@@ -394,6 +399,7 @@ static bool TryGetCullingParameters(CameraData cameraData, out ScriptableCulling
         /// <param name="anyPostProcessingEnabled">True if at least one camera has post-processing enabled in the stack, false otherwise.</param>
         static void RenderSingleCamera(ScriptableRenderContext context, CameraData cameraData, bool anyPostProcessingEnabled)
         {
+            overrideVolumeStack = null;
             Camera camera = cameraData.camera;
             var renderer = cameraData.renderer;
             if (renderer == null)
@@ -716,7 +722,7 @@ static void UpdateVolumeFramework(Camera camera, UniversalAdditionalCameraData a
                     camera.UpdateVolumeStack(additionalCameraData);
                 }
 
-                VolumeManager.instance.stack = additionalCameraData.volumeStack;
+                overrideVolumeStack = additionalCameraData.volumeStack;
                 return;
             }
 
@@ -731,8 +737,7 @@ static void UpdateVolumeFramework(Camera camera, UniversalAdditionalCameraData a
 
             // Get the mask + trigger and update the stack
             camera.GetVolumeLayerMaskAndTrigger(additionalCameraData, out LayerMask layerMask, out Transform trigger);
-            VolumeManager.instance.ResetMainStack();
-            VolumeManager.instance.Update(trigger, layerMask);
+            VolumeManager.instance.Update(currentVolumeStack, trigger, layerMask);
         }
 
         static bool CheckPostProcessForDepth(in CameraData cameraData)
@@ -748,12 +753,10 @@ static bool CheckPostProcessForDepth(in CameraData cameraData)
 
         static bool CheckPostProcessForDepth()
         {
-            var stack = VolumeManager.instance.stack;
-
-            if (stack.GetComponent<DepthOfField>().IsActive())
+            if (currentVolumeStack.GetComponent<DepthOfField>().IsActive())
                 return true;
 
-            if (stack.GetComponent<MotionBlur>().IsActive())
+            if (currentVolumeStack.GetComponent<MotionBlur>().IsActive())
                 return true;
 
             return false;