diff --git a/Substrate.NetApi.Test/UtilsTests.cs b/Substrate.NetApi.Test/UtilsTests.cs
index cbc0770..ee6092c 100644
--- a/Substrate.NetApi.Test/UtilsTests.cs
+++ b/Substrate.NetApi.Test/UtilsTests.cs
@@ -121,7 +121,7 @@ public void StringValueArrayBytesArrayTest()
         [Test]
         public void StringValueArrayBytesArrayFailedTest()
         {
-            Assert.Throws<Exception>(delegate { Utils.StringValueArrayBytesArray("Test"); });
+            Assert.Throws<NotSupportedException>(delegate { Utils.StringValueArrayBytesArray("Test"); });
         }
 
         [Test]
@@ -138,7 +138,7 @@ public void Byte2ValueTest()
 
             Assert.AreEqual(0x1312, Utils.Bytes2Value(new byte[] { 0x13, 0x12 }, false));
 
-            Assert.Throws<Exception>(delegate
+            Assert.Throws<NotSupportedException>(delegate
             {
                 Utils.Bytes2Value(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF });
             });
@@ -147,7 +147,7 @@ public void Byte2ValueTest()
         [Test]
         public void HexToByteArrayFailedTest()
         {
-            Assert.Throws<Exception>(delegate { Utils.HexToByteArray("111"); });
+            Assert.Throws<NotSupportedException>(delegate { Utils.HexToByteArray("111"); });
         }
 
         [Test]
@@ -169,7 +169,7 @@ public void Value2BytesTest()
             Assert.AreEqual(new byte[] { 0x15, 0x14, 0x13, 0x12 }, Utils.Value2Bytes((uint)0x12131415));
             Assert.AreEqual(new byte[] { 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x09, 0x08 }, Utils.Value2Bytes((ulong)0x0809101112131415));
             Assert.AreEqual(new byte[] { 0x11, 0x12 }, Utils.Value2Bytes((ushort)0x1112, false));
-            Assert.Throws<Exception>(delegate { Utils.Value2Bytes(1.4); });
+            Assert.Throws<NotSupportedException>(delegate { Utils.Value2Bytes(1.4); });
         }
 
         [Test]
diff --git a/Substrate.NetApi.TestNode/BasicTest.cs b/Substrate.NetApi.TestNode/BasicTest.cs
index 9258788..a36960b 100644
--- a/Substrate.NetApi.TestNode/BasicTest.cs
+++ b/Substrate.NetApi.TestNode/BasicTest.cs
@@ -150,8 +150,6 @@ public async Task GetBlocknumberAtBlockHashTestAsync()
         /// </summary>
         public sealed class Arr32U8 : BaseType
         {
-            private U8[] _value;
-
             public override int TypeSize
             {
                 get
@@ -160,17 +158,7 @@ public override int TypeSize
                 }
             }
 
-            public U8[] Value
-            {
-                get
-                {
-                    return this._value;
-                }
-                set
-                {
-                    this._value = value;
-                }
-            }
+            public U8[] Value { get; set; }
 
             public override string TypeName()
             {
@@ -180,7 +168,7 @@ public override string TypeName()
             public override byte[] Encode()
             {
                 var result = new List<byte>();
-                foreach (var v in Value) { result.AddRange(v.Encode()); };
+                foreach (var v in Value) { result.AddRange(v.Encode()); }
                 return result.ToArray();
             }
 
@@ -188,7 +176,7 @@ public override void Decode(byte[] byteArray, ref int p)
             {
                 var start = p;
                 var array = new U8[TypeSize];
-                for (var i = 0; i < array.Length; i++) { var t = new U8(); t.Decode(byteArray, ref p); array[i] = t; };
+                for (var i = 0; i < array.Length; i++) { var t = new U8(); t.Decode(byteArray, ref p); array[i] = t; }
                 var bytesLength = p - start;
                 Bytes = new byte[bytesLength];
                 System.Array.Copy(byteArray, start, Bytes, 0, bytesLength);
diff --git a/Substrate.NetApi.TestNode/ExtrinsicsTest.cs b/Substrate.NetApi.TestNode/ExtrinsicsTest.cs
index f3cd67a..7319505 100644
--- a/Substrate.NetApi.TestNode/ExtrinsicsTest.cs
+++ b/Substrate.NetApi.TestNode/ExtrinsicsTest.cs
@@ -127,11 +127,9 @@ public async Task Extrinsic_TransactionUnstableUnwatchAsync()
             var subscriptionId = await _substrateClient.Unstable.TransactionUnstableSubmitAndWatchAsync(
                 (subscriptionId, extrinsicUpdate) =>
                 {
+                    if (extrinsicUpdate.TransactionEvent != TransactionEvent.Validated)
                     {
-                        if (extrinsicUpdate.TransactionEvent != TransactionEvent.Validated)
-                        {
-                            taskCompletionSource.SetResult(true);
-                        }
+                        taskCompletionSource.SetResult(true);
                     }
                 },
                 method, Alice, _chargeType, 64, cancellationTokenSource.Token);
diff --git a/Substrate.NetApi.TestNode/ModuleStateTest.cs b/Substrate.NetApi.TestNode/ModuleStateTest.cs
index 85fc4e6..d9ebb43 100644
--- a/Substrate.NetApi.TestNode/ModuleStateTest.cs
+++ b/Substrate.NetApi.TestNode/ModuleStateTest.cs
@@ -27,7 +27,7 @@ public async Task GetKeysPagedAtTestAsync()
 
             var blockHash = await _substrateClient.Chain.GetBlockHashAsync(blockNumber);
 
-            var result = await _substrateClient.State.GetKeysPagedAtAsync(RequestGenerator.GetStorageKeyBytesHash("System", "BlockHash"), 10, null, blockHash.Bytes, CancellationToken.None);
+            var result = await _substrateClient.State.GetKeysPagedAsync(RequestGenerator.GetStorageKeyBytesHash("System", "BlockHash"), 10, null, blockHash.Bytes, CancellationToken.None);
 
             Assert.IsNotNull(result);
             Assert.AreEqual(10, result.Count);
@@ -68,8 +68,8 @@ public async Task GetMetaDataAt_ShouldWorkAsync()
         {
             var blockHash = await GivenBlockAsync();
 
-            var metadata_1 = await _substrateClient.State.GetMetaDataAtAsync(blockHash, CancellationToken.None);
-            var metadata_2 = await _substrateClient.State.GetMetaDataAtAsync(Utils.Bytes2HexString(blockHash), CancellationToken.None);
+            var metadata_1 = await _substrateClient.State.GetMetaDataAsync(blockHash, CancellationToken.None);
+            var metadata_2 = await _substrateClient.State.GetMetaDataAsync(Utils.Bytes2HexString(blockHash), CancellationToken.None);
 
             Assert.That(metadata_1, Is.Not.Null);
             Assert.That(metadata_2, Is.Not.Null);
@@ -99,8 +99,8 @@ public async Task GetRuntimeVersionAt_ShouldWorkAsync()
         {
             var blockHash = await GivenBlockAsync();
 
-            var runtimeVersion_1 = await _substrateClient.State.GetRuntimeVersionAtAsync(blockHash, CancellationToken.None);
-            var runtimeVersion_2 = await _substrateClient.State.GetRuntimeVersionAtAsync(Utils.Bytes2HexString(blockHash), CancellationToken.None);
+            var runtimeVersion_1 = await _substrateClient.State.GetRuntimeVersionAsync(blockHash, CancellationToken.None);
+            var runtimeVersion_2 = await _substrateClient.State.GetRuntimeVersionAsync(Utils.Bytes2HexString(blockHash), CancellationToken.None);
 
             Assert.That(runtimeVersion_1, Is.Not.Null);
             Assert.That(runtimeVersion_2, Is.Not.Null);
@@ -136,8 +136,8 @@ public async Task GetReadProofAt_ShouldWorkAsync(string storageKeyHex)
             var blockHash = await GivenBlockAsync();
             var storageKeys = new List<byte[]>() { Utils.HexToByteArray(storageKeyHex) };
 
-            var call_1 = await _substrateClient.State.GetReadProofAtAsync(storageKeys, blockHash, CancellationToken.None);
-            var call_2 = await _substrateClient.State.GetReadProofAtAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
+            var call_1 = await _substrateClient.State.GetReadProofAsync(storageKeys, blockHash, CancellationToken.None);
+            var call_2 = await _substrateClient.State.GetReadProofAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
 
             Assert.That(call_1, Is.Not.Null);
             Assert.That(call_2, Is.Not.Null);
@@ -166,8 +166,8 @@ public async Task GetStorageAt_ShouldWorkAsync(string storageKeyHex)
             var blockHash = await GivenBlockAsync();
             var storageKeys = Utils.HexToByteArray(storageKeyHex);
 
-            var call_1 = await _substrateClient.State.GetStorageAtAsync(storageKeys, blockHash, CancellationToken.None);
-            var call_2 = await _substrateClient.State.GetStorageAtAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
+            var call_1 = await _substrateClient.State.GetStorageAsync(storageKeys, blockHash, CancellationToken.None);
+            var call_2 = await _substrateClient.State.GetStorageAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
 
             Assert.That(call_1, Is.Not.Null);
             Assert.That(call_2, Is.Not.Null);
@@ -195,8 +195,8 @@ public async Task GetStorageHashAt_ShouldWorkAsync(string storageKeyHex)
             var blockHash = await GivenBlockAsync();
             var storageKeys = Utils.HexToByteArray(storageKeyHex);
 
-            var call_1 = await _substrateClient.State.GetStorageHashAtAsync(storageKeys, blockHash, CancellationToken.None);
-            var call_2 = await _substrateClient.State.GetStorageHashAtAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
+            var call_1 = await _substrateClient.State.GetStorageHashAsync(storageKeys, blockHash, CancellationToken.None);
+            var call_2 = await _substrateClient.State.GetStorageHashAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
 
             Assert.That(call_1, Is.Not.Null);
             Assert.That(call_2, Is.Not.Null);
@@ -224,8 +224,8 @@ public async Task GetStorageSizeAt_ShouldWorkAsync(string storageKeyHex)
             var blockHash = await GivenBlockAsync();
             var storageKeys = Utils.HexToByteArray(storageKeyHex);
 
-            var call_1 = await _substrateClient.State.GetStorageSizeAtAsync(storageKeys, blockHash, CancellationToken.None);
-            var call_2 = await _substrateClient.State.GetStorageSizeAtAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
+            var call_1 = await _substrateClient.State.GetStorageSizeAsync(storageKeys, blockHash, CancellationToken.None);
+            var call_2 = await _substrateClient.State.GetStorageSizeAsync(storageKeys, Utils.Bytes2HexString(blockHash), CancellationToken.None);
 
             Assert.That(call_1, Is.Not.Null);
             Assert.That(call_2, Is.Not.Null);
@@ -237,21 +237,43 @@ public async Task GetStorageSizeAt_ShouldWorkAsync(string storageKeyHex)
         [TestCase("0xf0c365c3cf59d671eb72da0e7a4113c49f1f0515f462cdcf84e0f1d6045dfcbb")]
         public async Task SubscribeStorage_ShouldWorkAsync(string storageKeyHex)
         {
-            Action<string, StorageChangeSet> callBack = (key, storacheChangeSet) =>
+            var tcs = new TaskCompletionSource<bool>();
+
+            Action<string, StorageChangeSet> callBack = (key, storageChangeSet) =>
             {
-                Assert.AreEqual("String", key.GetType().Name);
-                Assert.AreEqual(1, storacheChangeSet.Changes.Length);
-                Assert.AreEqual(2, storacheChangeSet.Changes[0].Length);
-                Assert.AreEqual(storageKeyHex, storacheChangeSet.Changes[0][0]);
+                try
+                {
+                    Assert.AreEqual("String", key.GetType().Name);
+                    Assert.AreEqual(1, storageChangeSet.Changes.Length);
+                    Assert.AreEqual(2, storageChangeSet.Changes[0].Length);
+                    Assert.AreEqual(storageKeyHex, storageChangeSet.Changes[0][0]);
+
+                    tcs.SetResult(true); // Signal that the test can continue
+                }
+                catch (Exception ex)
+                {
+                    tcs.SetException(ex); // Propagate the exception to the awaiting test
+                }
             };
 
             var subscriptionId = await _substrateClient.State.SubscribeStorageAsync(new JArray() { storageKeyHex }, callBack, CancellationToken.None);
 
-            Thread.Sleep(20 * 1000);
+            // Wait for the callback to complete or timeout after 20 seconds
+            if (await Task.WhenAny(tcs.Task, Task.Delay(20000)) == tcs.Task)
+            {
+                // The callback completed within 20 seconds
+                await tcs.Task; // Rethrow exception if the test failed
+            }
+            else
+            {
+                // The test timed out
+                Assert.Fail("Test timed out.");
+            }
 
             await _substrateClient.State.UnsubscribeStorageAsync(subscriptionId, CancellationToken.None);
         }
 
+
         [Test]
         public void SubscribeStorageAll_Failure()
         {
diff --git a/Substrate.NetApi/Attributes/SubstrateNodeType.cs b/Substrate.NetApi/Attributes/SubstrateNodeType.cs
index 0b96f71..8c4e87d 100644
--- a/Substrate.NetApi/Attributes/SubstrateNodeType.cs
+++ b/Substrate.NetApi/Attributes/SubstrateNodeType.cs
@@ -3,11 +3,21 @@
 
 namespace Substrate.NetApi.Attributes
 {
+    /// <summary>
+    /// Substrate Node Type Attribute
+    /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class SubstrateNodeTypeAttribute : Attribute
     {
+        /// <summary>
+        /// Node Type
+        /// </summary>
         public TypeDefEnum NodeType { get; set; }
 
+        /// <summary>
+        /// Substrate Node Type Attribute
+        /// </summary>
+        /// <param name="nodeType"></param>
         public SubstrateNodeTypeAttribute(TypeDefEnum nodeType)
         {
             NodeType = nodeType;
diff --git a/Substrate.NetApi/BIP39/LanguageWordLists.cs b/Substrate.NetApi/BIP39/LanguageWordLists.cs
index 142cfa8..ff315ed 100644
--- a/Substrate.NetApi/BIP39/LanguageWordLists.cs
+++ b/Substrate.NetApi/BIP39/LanguageWordLists.cs
@@ -2,91 +2,181 @@
 {
     //Words obtained from wordlist documented at https://github.com/bitcoin/bips/blob/master/bip-0039/bip-0039-wordlists.md
 
+    /// <summary>
+    /// Chinese Simplified Words
+    /// </summary>
     public class ChineseSimplified : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "的", "一", "是", "在", "不", "了", "有", "和", "人", "这", "中", "大", "为", "上", "个", "国", "我", "以", "要", "他", "时", "来", "用", "们", "生", "到", "作", "地", "于", "出", "就", "分", "对", "成", "会", "可", "主", "发", "年", "动", "同", "工", "也", "能", "下", "过", "子", "说", "产", "种", "面", "而", "方", "后", "多", "定", "行", "学", "法", "所", "民", "得", "经", "十", "三", "之", "进", "着", "等", "部", "度", "家", "电", "力", "里", "如", "水", "化", "高", "自", "二", "理", "起", "小", "物", "现", "实", "加", "量", "都", "两", "体", "制", "机", "当", "使", "点", "从", "业", "本", "去", "把", "性", "好", "应", "开", "它", "合", "还", "因", "由", "其", "些", "然", "前", "外", "天", "政", "四", "日", "那", "社", "义", "事", "平", "形", "相", "全", "表", "间", "样", "与", "关", "各", "重", "新", "线", "内", "数", "正", "心", "反", "你", "明", "看", "原", "又", "么", "利", "比", "或", "但", "质", "气", "第", "向", "道", "命", "此", "变", "条", "只", "没", "结", "解", "问", "意", "建", "月", "公", "无", "系", "军", "很", "情", "者", "最", "立", "代", "想", "已", "通", "并", "提", "直", "题", "党", "程", "展", "五", "果", "料", "象", "员", "革", "位", "入", "常", "文", "总", "次", "品", "式", "活", "设", "及", "管", "特", "件", "长", "求", "老", "头", "基", "资", "边", "流", "路", "级", "少", "图", "山", "统", "接", "知", "较", "将", "组", "见", "计", "别", "她", "手", "角", "期", "根", "论", "运", "农", "指", "几", "九", "区", "强", "放", "决", "西", "被", "干", "做", "必", "战", "先", "回", "则", "任", "取", "据", "处", "队", "南", "给", "色", "光", "门", "即", "保", "治", "北", "造", "百", "规", "热", "领", "七", "海", "口", "东", "导", "器", "压", "志", "世", "金", "增", "争", "济", "阶", "油", "思", "术", "极", "交", "受", "联", "什", "认", "六", "共", "权", "收", "证", "改", "清", "美", "再", "采", "转", "更", "单", "风", "切", "打", "白", "教", "速", "花", "带", "安", "场", "身", "车", "例", "真", "务", "具", "万", "每", "目", "至", "达", "走", "积", "示", "议", "声", "报", "斗", "完", "类", "八", "离", "华", "名", "确", "才", "科", "张", "信", "马", "节", "话", "米", "整", "空", "元", "况", "今", "集", "温", "传", "土", "许", "步", "群", "广", "石", "记", "需", "段", "研", "界", "拉", "林", "律", "叫", "且", "究", "观", "越", "织", "装", "影", "算", "低", "持", "音", "众", "书", "布", "复", "容", "儿", "须", "际", "商", "非", "验", "连", "断", "深", "难", "近", "矿", "千", "周", "委", "素", "技", "备", "半", "办", "青", "省", "列", "习", "响", "约", "支", "般", "史", "感", "劳", "便", "团", "往", "酸", "历", "市", "克", "何", "除", "消", "构", "府", "称", "太", "准", "精", "值", "号", "率", "族", "维", "划", "选", "标", "写", "存", "候", "毛", "亲", "快", "效", "斯", "院", "查", "江", "型", "眼", "王", "按", "格", "养", "易", "置", "派", "层", "片", "始", "却", "专", "状", "育", "厂", "京", "识", "适", "属", "圆", "包", "火", "住", "调", "满", "县", "局", "照", "参", "红", "细", "引", "听", "该", "铁", "价", "严", "首", "底", "液", "官", "德", "随", "病", "苏", "失", "尔", "死", "讲", "配", "女", "黄", "推", "显", "谈", "罪", "神", "艺", "呢", "席", "含", "企", "望", "密", "批", "营", "项", "防", "举", "球", "英", "氧", "势", "告", "李", "台", "落", "木", "帮", "轮", "破", "亚", "师", "围", "注", "远", "字", "材", "排", "供", "河", "态", "封", "另", "施", "减", "树", "溶", "怎", "止", "案", "言", "士", "均", "武", "固", "叶", "鱼", "波", "视", "仅", "费", "紧", "爱", "左", "章", "早", "朝", "害", "续", "轻", "服", "试", "食", "充", "兵", "源", "判", "护", "司", "足", "某", "练", "差", "致", "板", "田", "降", "黑", "犯", "负", "击", "范", "继", "兴", "似", "余", "坚", "曲", "输", "修", "故", "城", "夫", "够", "送", "笔", "船", "占", "右", "财", "吃", "富", "春", "职", "觉", "汉", "画", "功", "巴", "跟", "虽", "杂", "飞", "检", "吸", "助", "升", "阳", "互", "初", "创", "抗", "考", "投", "坏", "策", "古", "径", "换", "未", "跑", "留", "钢", "曾", "端", "责", "站", "简", "述", "钱", "副", "尽", "帝", "射", "草", "冲", "承", "独", "令", "限", "阿", "宣", "环", "双", "请", "超", "微", "让", "控", "州", "良", "轴", "找", "否", "纪", "益", "依", "优", "顶", "础", "载", "倒", "房", "突", "坐", "粉", "敌", "略", "客", "袁", "冷", "胜", "绝", "析", "块", "剂", "测", "丝", "协", "诉", "念", "陈", "仍", "罗", "盐", "友", "洋", "错", "苦", "夜", "刑", "移", "频", "逐", "靠", "混", "母", "短", "皮", "终", "聚", "汽", "村", "云", "哪", "既", "距", "卫", "停", "烈", "央", "察", "烧", "迅", "境", "若", "印", "洲", "刻", "括", "激", "孔", "搞", "甚", "室", "待", "核", "校", "散", "侵", "吧", "甲", "游", "久", "菜", "味", "旧", "模", "湖", "货", "损", "预", "阻", "毫", "普", "稳", "乙", "妈", "植", "息", "扩", "银", "语", "挥", "酒", "守", "拿", "序", "纸", "医", "缺", "雨", "吗", "针", "刘", "啊", "急", "唱", "误", "训", "愿", "审", "附", "获", "茶", "鲜", "粮", "斤", "孩", "脱", "硫", "肥", "善", "龙", "演", "父", "渐", "血", "欢", "械", "掌", "歌", "沙", "刚", "攻", "谓", "盾", "讨", "晚", "粒", "乱", "燃", "矛", "乎", "杀", "药", "宁", "鲁", "贵", "钟", "煤", "读", "班", "伯", "香", "介", "迫", "句", "丰", "培", "握", "兰", "担", "弦", "蛋", "沉", "假", "穿", "执", "答", "乐", "谁", "顺", "烟", "缩", "征", "脸", "喜", "松", "脚", "困", "异", "免", "背", "星", "福", "买", "染", "井", "概", "慢", "怕", "磁", "倍", "祖", "皇", "促", "静", "补", "评", "翻", "肉", "践", "尼", "衣", "宽", "扬", "棉", "希", "伤", "操", "垂", "秋", "宜", "氢", "套", "督", "振", "架", "亮", "末", "宪", "庆", "编", "牛", "触", "映", "雷", "销", "诗", "座", "居", "抓", "裂", "胞", "呼", "娘", "景", "威", "绿", "晶", "厚", "盟", "衡", "鸡", "孙", "延", "危", "胶", "屋", "乡", "临", "陆", "顾", "掉", "呀", "灯", "岁", "措", "束", "耐", "剧", "玉", "赵", "跳", "哥", "季", "课", "凯", "胡", "额", "款", "绍", "卷", "齐", "伟", "蒸", "殖", "永", "宗", "苗", "川", "炉", "岩", "弱", "零", "杨", "奏", "沿", "露", "杆", "探", "滑", "镇", "饭", "浓", "航", "怀", "赶", "库", "夺", "伊", "灵", "税", "途", "灭", "赛", "归", "召", "鼓", "播", "盘", "裁", "险", "康", "唯", "录", "菌", "纯", "借", "糖", "盖", "横", "符", "私", "努", "堂", "域", "枪", "润", "幅", "哈", "竟", "熟", "虫", "泽", "脑", "壤", "碳", "欧", "遍", "侧", "寨", "敢", "彻", "虑", "斜", "薄", "庭", "纳", "弹", "饲", "伸", "折", "麦", "湿", "暗", "荷", "瓦", "塞", "床", "筑", "恶", "户", "访", "塔", "奇", "透", "梁", "刀", "旋", "迹", "卡", "氯", "遇", "份", "毒", "泥", "退", "洗", "摆", "灰", "彩", "卖", "耗", "夏", "择", "忙", "铜", "献", "硬", "予", "繁", "圈", "雪", "函", "亦", "抽", "篇", "阵", "阴", "丁", "尺", "追", "堆", "雄", "迎", "泛", "爸", "楼", "避", "谋", "吨", "野", "猪", "旗", "累", "偏", "典", "馆", "索", "秦", "脂", "潮", "爷", "豆", "忽", "托", "惊", "塑", "遗", "愈", "朱", "替", "纤", "粗", "倾", "尚", "痛", "楚", "谢", "奋", "购", "磨", "君", "池", "旁", "碎", "骨", "监", "捕", "弟", "暴", "割", "贯", "殊", "释", "词", "亡", "壁", "顿", "宝", "午", "尘", "闻", "揭", "炮", "残", "冬", "桥", "妇", "警", "综", "招", "吴", "付", "浮", "遭", "徐", "您", "摇", "谷", "赞", "箱", "隔", "订", "男", "吹", "园", "纷", "唐", "败", "宋", "玻", "巨", "耕", "坦", "荣", "闭", "湾", "键", "凡", "驻", "锅", "救", "恩", "剥", "凝", "碱", "齿", "截", "炼", "麻", "纺", "禁", "废", "盛", "版", "缓", "净", "睛", "昌", "婚", "涉", "筒", "嘴", "插", "岸", "朗", "庄", "街", "藏", "姑", "贸", "腐", "奴", "啦", "惯", "乘", "伙", "恢", "匀", "纱", "扎", "辩", "耳", "彪", "臣", "亿", "璃", "抵", "脉", "秀", "萨", "俄", "网", "舞", "店", "喷", "纵", "寸", "汗", "挂", "洪", "贺", "闪", "柬", "爆", "烯", "津", "稻", "墙", "软", "勇", "像", "滚", "厘", "蒙", "芳", "肯", "坡", "柱", "荡", "腿", "仪", "旅", "尾", "轧", "冰", "贡", "登", "黎", "削", "钻", "勒", "逃", "障", "氨", "郭", "峰", "币", "港", "伏", "轨", "亩", "毕", "擦", "莫", "刺", "浪", "秘", "援", "株", "健", "售", "股", "岛", "甘", "泡", "睡", "童", "铸", "汤", "阀", "休", "汇", "舍", "牧", "绕", "炸", "哲", "磷", "绩", "朋", "淡", "尖", "启", "陷", "柴", "呈", "徒", "颜", "泪", "稍", "忘", "泵", "蓝", "拖", "洞", "授", "镜", "辛", "壮", "锋", "贫", "虚", "弯", "摩", "泰", "幼", "廷", "尊", "窗", "纲", "弄", "隶", "疑", "氏", "宫", "姐", "震", "瑞", "怪", "尤", "琴", "循", "描", "膜", "违", "夹", "腰", "缘", "珠", "穷", "森", "枝", "竹", "沟", "催", "绳", "忆", "邦", "剩", "幸", "浆", "栏", "拥", "牙", "贮", "礼", "滤", "钠", "纹", "罢", "拍", "咱", "喊", "袖", "埃", "勤", "罚", "焦", "潜", "伍", "墨", "欲", "缝", "姓", "刊", "饱", "仿", "奖", "铝", "鬼", "丽", "跨", "默", "挖", "链", "扫", "喝", "袋", "炭", "污", "幕", "诸", "弧", "励", "梅", "奶", "洁", "灾", "舟", "鉴", "苯", "讼", "抱", "毁", "懂", "寒", "智", "埔", "寄", "届", "跃", "渡", "挑", "丹", "艰", "贝", "碰", "拔", "爹", "戴", "码", "梦", "芽", "熔", "赤", "渔", "哭", "敬", "颗", "奔", "铅", "仲", "虎", "稀", "妹", "乏", "珍", "申", "桌", "遵", "允", "隆", "螺", "仓", "魏", "锐", "晓", "氮", "兼", "隐", "碍", "赫", "拨", "忠", "肃", "缸", "牵", "抢", "博", "巧", "壳", "兄", "杜", "讯", "诚", "碧", "祥", "柯", "页", "巡", "矩", "悲", "灌", "龄", "伦", "票", "寻", "桂", "铺", "圣", "恐", "恰", "郑", "趣", "抬", "荒", "腾", "贴", "柔", "滴", "猛", "阔", "辆", "妻", "填", "撤", "储", "签", "闹", "扰", "紫", "砂", "递", "戏", "吊", "陶", "伐", "喂", "疗", "瓶", "婆", "抚", "臂", "摸", "忍", "虾", "蜡", "邻", "胸", "巩", "挤", "偶", "弃", "槽", "劲", "乳", "邓", "吉", "仁", "烂", "砖", "租", "乌", "舰", "伴", "瓜", "浅", "丙", "暂", "燥", "橡", "柳", "迷", "暖", "牌", "秧", "胆", "详", "簧", "踏", "瓷", "谱", "呆", "宾", "糊", "洛", "辉", "愤", "竞", "隙", "怒", "粘", "乃", "绪", "肩", "籍", "敏", "涂", "熙", "皆", "侦", "悬", "掘", "享", "纠", "醒", "狂", "锁", "淀", "恨", "牲", "霸", "爬", "赏", "逆", "玩", "陵", "祝", "秒", "浙", "貌", "役", "彼", "悉", "鸭", "趋", "凤", "晨", "畜", "辈", "秩", "卵", "署", "梯", "炎", "滩", "棋", "驱", "筛", "峡", "冒", "啥", "寿", "译", "浸", "泉", "帽", "迟", "硅", "疆", "贷", "漏", "稿", "冠", "嫩", "胁", "芯", "牢", "叛", "蚀", "奥", "鸣", "岭", "羊", "凭", "串", "塘", "绘", "酵", "融", "盆", "锡", "庙", "筹", "冻", "辅", "摄", "袭", "筋", "拒", "僚", "旱", "钾", "鸟", "漆", "沈", "眉", "疏", "添", "棒", "穗", "硝", "韩", "逼", "扭", "侨", "凉", "挺", "碗", "栽", "炒", "杯", "患", "馏", "劝", "豪", "辽", "勃", "鸿", "旦", "吏", "拜", "狗", "埋", "辊", "掩", "饮", "搬", "骂", "辞", "勾", "扣", "估", "蒋", "绒", "雾", "丈", "朵", "姆", "拟", "宇", "辑", "陕", "雕", "偿", "蓄", "崇", "剪", "倡", "厅", "咬", "驶", "薯", "刷", "斥", "番", "赋", "奉", "佛", "浇", "漫", "曼", "扇", "钙", "桃", "扶", "仔", "返", "俗", "亏", "腔", "鞋", "棱", "覆", "框", "悄", "叔", "撞", "骗", "勘", "旺", "沸", "孤", "吐", "孟", "渠", "屈", "疾", "妙", "惜", "仰", "狠", "胀", "谐", "抛", "霉", "桑", "岗", "嘛", "衰", "盗", "渗", "脏", "赖", "涌", "甜", "曹", "阅", "肌", "哩", "厉", "烃", "纬", "毅", "昨", "伪", "症", "煮", "叹", "钉", "搭", "茎", "笼", "酷", "偷", "弓", "锥", "恒", "杰", "坑", "鼻", "翼", "纶", "叙", "狱", "逮", "罐", "络", "棚", "抑", "膨", "蔬", "寺", "骤", "穆", "冶", "枯", "册", "尸", "凸", "绅", "坯", "牺", "焰", "轰", "欣", "晋", "瘦", "御", "锭", "锦", "丧", "旬", "锻", "垄", "搜", "扑", "邀", "亭", "酯", "迈", "舒", "脆", "酶", "闲", "忧", "酚", "顽", "羽", "涨", "卸", "仗", "陪", "辟", "惩", "杭", "姚", "肚", "捉", "飘", "漂", "昆", "欺", "吾", "郎", "烷", "汁", "呵", "饰", "萧", "雅", "邮", "迁", "燕", "撒", "姻", "赴", "宴", "烦", "债", "帐", "斑", "铃", "旨", "醇", "董", "饼", "雏", "姿", "拌", "傅", "腹", "妥", "揉", "贤", "拆", "歪", "葡", "胺", "丢", "浩", "徽", "昂", "垫", "挡", "览", "贪", "慰", "缴", "汪", "慌", "冯", "诺", "姜", "谊", "凶", "劣", "诬", "耀", "昏", "躺", "盈", "骑", "乔", "溪", "丛", "卢", "抹", "闷", "咨", "刮", "驾", "缆", "悟", "摘", "铒", "掷", "颇", "幻", "柄", "惠", "惨", "佳", "仇", "腊", "窝", "涤", "剑", "瞧", "堡", "泼", "葱", "罩", "霍", "捞", "胎", "苍", "滨", "俩", "捅", "湘", "砍", "霞", "邵", "萄", "疯", "淮", "遂", "熊", "粪", "烘", "宿", "档", "戈", "驳", "嫂", "裕", "徙", "箭", "捐", "肠", "撑", "晒", "辨", "殿", "莲", "摊", "搅", "酱", "屏", "疫", "哀", "蔡", "堵", "沫", "皱", "畅", "叠", "阁", "莱", "敲", "辖", "钩", "痕", "坝", "巷", "饿", "祸", "丘", "玄", "溜", "曰", "逻", "彭", "尝", "卿", "妨", "艇", "吞", "韦", "怨", "矮", "歇" };
 
+        /// <summary>
+        /// Chinese Simplified Constructor
+        /// </summary>
         public ChineseSimplified() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Chinese Traditional Words
+    /// </summary>
     public class ChineseTraditional : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "的", "一", "是", "在", "不", "了", "有", "和", "人", "這", "中", "大", "為", "上", "個", "國", "我", "以", "要", "他", "時", "來", "用", "們", "生", "到", "作", "地", "於", "出", "就", "分", "對", "成", "會", "可", "主", "發", "年", "動", "同", "工", "也", "能", "下", "過", "子", "說", "產", "種", "面", "而", "方", "後", "多", "定", "行", "學", "法", "所", "民", "得", "經", "十", "三", "之", "進", "著", "等", "部", "度", "家", "電", "力", "裡", "如", "水", "化", "高", "自", "二", "理", "起", "小", "物", "現", "實", "加", "量", "都", "兩", "體", "制", "機", "當", "使", "點", "從", "業", "本", "去", "把", "性", "好", "應", "開", "它", "合", "還", "因", "由", "其", "些", "然", "前", "外", "天", "政", "四", "日", "那", "社", "義", "事", "平", "形", "相", "全", "表", "間", "樣", "與", "關", "各", "重", "新", "線", "內", "數", "正", "心", "反", "你", "明", "看", "原", "又", "麼", "利", "比", "或", "但", "質", "氣", "第", "向", "道", "命", "此", "變", "條", "只", "沒", "結", "解", "問", "意", "建", "月", "公", "無", "系", "軍", "很", "情", "者", "最", "立", "代", "想", "已", "通", "並", "提", "直", "題", "黨", "程", "展", "五", "果", "料", "象", "員", "革", "位", "入", "常", "文", "總", "次", "品", "式", "活", "設", "及", "管", "特", "件", "長", "求", "老", "頭", "基", "資", "邊", "流", "路", "級", "少", "圖", "山", "統", "接", "知", "較", "將", "組", "見", "計", "別", "她", "手", "角", "期", "根", "論", "運", "農", "指", "幾", "九", "區", "強", "放", "決", "西", "被", "幹", "做", "必", "戰", "先", "回", "則", "任", "取", "據", "處", "隊", "南", "給", "色", "光", "門", "即", "保", "治", "北", "造", "百", "規", "熱", "領", "七", "海", "口", "東", "導", "器", "壓", "志", "世", "金", "增", "爭", "濟", "階", "油", "思", "術", "極", "交", "受", "聯", "什", "認", "六", "共", "權", "收", "證", "改", "清", "美", "再", "採", "轉", "更", "單", "風", "切", "打", "白", "教", "速", "花", "帶", "安", "場", "身", "車", "例", "真", "務", "具", "萬", "每", "目", "至", "達", "走", "積", "示", "議", "聲", "報", "鬥", "完", "類", "八", "離", "華", "名", "確", "才", "科", "張", "信", "馬", "節", "話", "米", "整", "空", "元", "況", "今", "集", "溫", "傳", "土", "許", "步", "群", "廣", "石", "記", "需", "段", "研", "界", "拉", "林", "律", "叫", "且", "究", "觀", "越", "織", "裝", "影", "算", "低", "持", "音", "眾", "書", "布", "复", "容", "兒", "須", "際", "商", "非", "驗", "連", "斷", "深", "難", "近", "礦", "千", "週", "委", "素", "技", "備", "半", "辦", "青", "省", "列", "習", "響", "約", "支", "般", "史", "感", "勞", "便", "團", "往", "酸", "歷", "市", "克", "何", "除", "消", "構", "府", "稱", "太", "準", "精", "值", "號", "率", "族", "維", "劃", "選", "標", "寫", "存", "候", "毛", "親", "快", "效", "斯", "院", "查", "江", "型", "眼", "王", "按", "格", "養", "易", "置", "派", "層", "片", "始", "卻", "專", "狀", "育", "廠", "京", "識", "適", "屬", "圓", "包", "火", "住", "調", "滿", "縣", "局", "照", "參", "紅", "細", "引", "聽", "該", "鐵", "價", "嚴", "首", "底", "液", "官", "德", "隨", "病", "蘇", "失", "爾", "死", "講", "配", "女", "黃", "推", "顯", "談", "罪", "神", "藝", "呢", "席", "含", "企", "望", "密", "批", "營", "項", "防", "舉", "球", "英", "氧", "勢", "告", "李", "台", "落", "木", "幫", "輪", "破", "亞", "師", "圍", "注", "遠", "字", "材", "排", "供", "河", "態", "封", "另", "施", "減", "樹", "溶", "怎", "止", "案", "言", "士", "均", "武", "固", "葉", "魚", "波", "視", "僅", "費", "緊", "愛", "左", "章", "早", "朝", "害", "續", "輕", "服", "試", "食", "充", "兵", "源", "判", "護", "司", "足", "某", "練", "差", "致", "板", "田", "降", "黑", "犯", "負", "擊", "范", "繼", "興", "似", "餘", "堅", "曲", "輸", "修", "故", "城", "夫", "夠", "送", "筆", "船", "佔", "右", "財", "吃", "富", "春", "職", "覺", "漢", "畫", "功", "巴", "跟", "雖", "雜", "飛", "檢", "吸", "助", "昇", "陽", "互", "初", "創", "抗", "考", "投", "壞", "策", "古", "徑", "換", "未", "跑", "留", "鋼", "曾", "端", "責", "站", "簡", "述", "錢", "副", "盡", "帝", "射", "草", "衝", "承", "獨", "令", "限", "阿", "宣", "環", "雙", "請", "超", "微", "讓", "控", "州", "良", "軸", "找", "否", "紀", "益", "依", "優", "頂", "礎", "載", "倒", "房", "突", "坐", "粉", "敵", "略", "客", "袁", "冷", "勝", "絕", "析", "塊", "劑", "測", "絲", "協", "訴", "念", "陳", "仍", "羅", "鹽", "友", "洋", "錯", "苦", "夜", "刑", "移", "頻", "逐", "靠", "混", "母", "短", "皮", "終", "聚", "汽", "村", "雲", "哪", "既", "距", "衛", "停", "烈", "央", "察", "燒", "迅", "境", "若", "印", "洲", "刻", "括", "激", "孔", "搞", "甚", "室", "待", "核", "校", "散", "侵", "吧", "甲", "遊", "久", "菜", "味", "舊", "模", "湖", "貨", "損", "預", "阻", "毫", "普", "穩", "乙", "媽", "植", "息", "擴", "銀", "語", "揮", "酒", "守", "拿", "序", "紙", "醫", "缺", "雨", "嗎", "針", "劉", "啊", "急", "唱", "誤", "訓", "願", "審", "附", "獲", "茶", "鮮", "糧", "斤", "孩", "脫", "硫", "肥", "善", "龍", "演", "父", "漸", "血", "歡", "械", "掌", "歌", "沙", "剛", "攻", "謂", "盾", "討", "晚", "粒", "亂", "燃", "矛", "乎", "殺", "藥", "寧", "魯", "貴", "鐘", "煤", "讀", "班", "伯", "香", "介", "迫", "句", "豐", "培", "握", "蘭", "擔", "弦", "蛋", "沉", "假", "穿", "執", "答", "樂", "誰", "順", "煙", "縮", "徵", "臉", "喜", "松", "腳", "困", "異", "免", "背", "星", "福", "買", "染", "井", "概", "慢", "怕", "磁", "倍", "祖", "皇", "促", "靜", "補", "評", "翻", "肉", "踐", "尼", "衣", "寬", "揚", "棉", "希", "傷", "操", "垂", "秋", "宜", "氫", "套", "督", "振", "架", "亮", "末", "憲", "慶", "編", "牛", "觸", "映", "雷", "銷", "詩", "座", "居", "抓", "裂", "胞", "呼", "娘", "景", "威", "綠", "晶", "厚", "盟", "衡", "雞", "孫", "延", "危", "膠", "屋", "鄉", "臨", "陸", "顧", "掉", "呀", "燈", "歲", "措", "束", "耐", "劇", "玉", "趙", "跳", "哥", "季", "課", "凱", "胡", "額", "款", "紹", "卷", "齊", "偉", "蒸", "殖", "永", "宗", "苗", "川", "爐", "岩", "弱", "零", "楊", "奏", "沿", "露", "桿", "探", "滑", "鎮", "飯", "濃", "航", "懷", "趕", "庫", "奪", "伊", "靈", "稅", "途", "滅", "賽", "歸", "召", "鼓", "播", "盤", "裁", "險", "康", "唯", "錄", "菌", "純", "借", "糖", "蓋", "橫", "符", "私", "努", "堂", "域", "槍", "潤", "幅", "哈", "竟", "熟", "蟲", "澤", "腦", "壤", "碳", "歐", "遍", "側", "寨", "敢", "徹", "慮", "斜", "薄", "庭", "納", "彈", "飼", "伸", "折", "麥", "濕", "暗", "荷", "瓦", "塞", "床", "築", "惡", "戶", "訪", "塔", "奇", "透", "梁", "刀", "旋", "跡", "卡", "氯", "遇", "份", "毒", "泥", "退", "洗", "擺", "灰", "彩", "賣", "耗", "夏", "擇", "忙", "銅", "獻", "硬", "予", "繁", "圈", "雪", "函", "亦", "抽", "篇", "陣", "陰", "丁", "尺", "追", "堆", "雄", "迎", "泛", "爸", "樓", "避", "謀", "噸", "野", "豬", "旗", "累", "偏", "典", "館", "索", "秦", "脂", "潮", "爺", "豆", "忽", "托", "驚", "塑", "遺", "愈", "朱", "替", "纖", "粗", "傾", "尚", "痛", "楚", "謝", "奮", "購", "磨", "君", "池", "旁", "碎", "骨", "監", "捕", "弟", "暴", "割", "貫", "殊", "釋", "詞", "亡", "壁", "頓", "寶", "午", "塵", "聞", "揭", "炮", "殘", "冬", "橋", "婦", "警", "綜", "招", "吳", "付", "浮", "遭", "徐", "您", "搖", "谷", "贊", "箱", "隔", "訂", "男", "吹", "園", "紛", "唐", "敗", "宋", "玻", "巨", "耕", "坦", "榮", "閉", "灣", "鍵", "凡", "駐", "鍋", "救", "恩", "剝", "凝", "鹼", "齒", "截", "煉", "麻", "紡", "禁", "廢", "盛", "版", "緩", "淨", "睛", "昌", "婚", "涉", "筒", "嘴", "插", "岸", "朗", "莊", "街", "藏", "姑", "貿", "腐", "奴", "啦", "慣", "乘", "夥", "恢", "勻", "紗", "扎", "辯", "耳", "彪", "臣", "億", "璃", "抵", "脈", "秀", "薩", "俄", "網", "舞", "店", "噴", "縱", "寸", "汗", "掛", "洪", "賀", "閃", "柬", "爆", "烯", "津", "稻", "牆", "軟", "勇", "像", "滾", "厘", "蒙", "芳", "肯", "坡", "柱", "盪", "腿", "儀", "旅", "尾", "軋", "冰", "貢", "登", "黎", "削", "鑽", "勒", "逃", "障", "氨", "郭", "峰", "幣", "港", "伏", "軌", "畝", "畢", "擦", "莫", "刺", "浪", "秘", "援", "株", "健", "售", "股", "島", "甘", "泡", "睡", "童", "鑄", "湯", "閥", "休", "匯", "舍", "牧", "繞", "炸", "哲", "磷", "績", "朋", "淡", "尖", "啟", "陷", "柴", "呈", "徒", "顏", "淚", "稍", "忘", "泵", "藍", "拖", "洞", "授", "鏡", "辛", "壯", "鋒", "貧", "虛", "彎", "摩", "泰", "幼", "廷", "尊", "窗", "綱", "弄", "隸", "疑", "氏", "宮", "姐", "震", "瑞", "怪", "尤", "琴", "循", "描", "膜", "違", "夾", "腰", "緣", "珠", "窮", "森", "枝", "竹", "溝", "催", "繩", "憶", "邦", "剩", "幸", "漿", "欄", "擁", "牙", "貯", "禮", "濾", "鈉", "紋", "罷", "拍", "咱", "喊", "袖", "埃", "勤", "罰", "焦", "潛", "伍", "墨", "欲", "縫", "姓", "刊", "飽", "仿", "獎", "鋁", "鬼", "麗", "跨", "默", "挖", "鏈", "掃", "喝", "袋", "炭", "污", "幕", "諸", "弧", "勵", "梅", "奶", "潔", "災", "舟", "鑑", "苯", "訟", "抱", "毀", "懂", "寒", "智", "埔", "寄", "屆", "躍", "渡", "挑", "丹", "艱", "貝", "碰", "拔", "爹", "戴", "碼", "夢", "芽", "熔", "赤", "漁", "哭", "敬", "顆", "奔", "鉛", "仲", "虎", "稀", "妹", "乏", "珍", "申", "桌", "遵", "允", "隆", "螺", "倉", "魏", "銳", "曉", "氮", "兼", "隱", "礙", "赫", "撥", "忠", "肅", "缸", "牽", "搶", "博", "巧", "殼", "兄", "杜", "訊", "誠", "碧", "祥", "柯", "頁", "巡", "矩", "悲", "灌", "齡", "倫", "票", "尋", "桂", "鋪", "聖", "恐", "恰", "鄭", "趣", "抬", "荒", "騰", "貼", "柔", "滴", "猛", "闊", "輛", "妻", "填", "撤", "儲", "簽", "鬧", "擾", "紫", "砂", "遞", "戲", "吊", "陶", "伐", "餵", "療", "瓶", "婆", "撫", "臂", "摸", "忍", "蝦", "蠟", "鄰", "胸", "鞏", "擠", "偶", "棄", "槽", "勁", "乳", "鄧", "吉", "仁", "爛", "磚", "租", "烏", "艦", "伴", "瓜", "淺", "丙", "暫", "燥", "橡", "柳", "迷", "暖", "牌", "秧", "膽", "詳", "簧", "踏", "瓷", "譜", "呆", "賓", "糊", "洛", "輝", "憤", "競", "隙", "怒", "粘", "乃", "緒", "肩", "籍", "敏", "塗", "熙", "皆", "偵", "懸", "掘", "享", "糾", "醒", "狂", "鎖", "淀", "恨", "牲", "霸", "爬", "賞", "逆", "玩", "陵", "祝", "秒", "浙", "貌", "役", "彼", "悉", "鴨", "趨", "鳳", "晨", "畜", "輩", "秩", "卵", "署", "梯", "炎", "灘", "棋", "驅", "篩", "峽", "冒", "啥", "壽", "譯", "浸", "泉", "帽", "遲", "矽", "疆", "貸", "漏", "稿", "冠", "嫩", "脅", "芯", "牢", "叛", "蝕", "奧", "鳴", "嶺", "羊", "憑", "串", "塘", "繪", "酵", "融", "盆", "錫", "廟", "籌", "凍", "輔", "攝", "襲", "筋", "拒", "僚", "旱", "鉀", "鳥", "漆", "沈", "眉", "疏", "添", "棒", "穗", "硝", "韓", "逼", "扭", "僑", "涼", "挺", "碗", "栽", "炒", "杯", "患", "餾", "勸", "豪", "遼", "勃", "鴻", "旦", "吏", "拜", "狗", "埋", "輥", "掩", "飲", "搬", "罵", "辭", "勾", "扣", "估", "蔣", "絨", "霧", "丈", "朵", "姆", "擬", "宇", "輯", "陝", "雕", "償", "蓄", "崇", "剪", "倡", "廳", "咬", "駛", "薯", "刷", "斥", "番", "賦", "奉", "佛", "澆", "漫", "曼", "扇", "鈣", "桃", "扶", "仔", "返", "俗", "虧", "腔", "鞋", "棱", "覆", "框", "悄", "叔", "撞", "騙", "勘", "旺", "沸", "孤", "吐", "孟", "渠", "屈", "疾", "妙", "惜", "仰", "狠", "脹", "諧", "拋", "黴", "桑", "崗", "嘛", "衰", "盜", "滲", "臟", "賴", "湧", "甜", "曹", "閱", "肌", "哩", "厲", "烴", "緯", "毅", "昨", "偽", "症", "煮", "嘆", "釘", "搭", "莖", "籠", "酷", "偷", "弓", "錐", "恆", "傑", "坑", "鼻", "翼", "綸", "敘", "獄", "逮", "罐", "絡", "棚", "抑", "膨", "蔬", "寺", "驟", "穆", "冶", "枯", "冊", "屍", "凸", "紳", "坯", "犧", "焰", "轟", "欣", "晉", "瘦", "禦", "錠", "錦", "喪", "旬", "鍛", "壟", "搜", "撲", "邀", "亭", "酯", "邁", "舒", "脆", "酶", "閒", "憂", "酚", "頑", "羽", "漲", "卸", "仗", "陪", "闢", "懲", "杭", "姚", "肚", "捉", "飄", "漂", "昆", "欺", "吾", "郎", "烷", "汁", "呵", "飾", "蕭", "雅", "郵", "遷", "燕", "撒", "姻", "赴", "宴", "煩", "債", "帳", "斑", "鈴", "旨", "醇", "董", "餅", "雛", "姿", "拌", "傅", "腹", "妥", "揉", "賢", "拆", "歪", "葡", "胺", "丟", "浩", "徽", "昂", "墊", "擋", "覽", "貪", "慰", "繳", "汪", "慌", "馮", "諾", "姜", "誼", "兇", "劣", "誣", "耀", "昏", "躺", "盈", "騎", "喬", "溪", "叢", "盧", "抹", "悶", "諮", "刮", "駕", "纜", "悟", "摘", "鉺", "擲", "頗", "幻", "柄", "惠", "慘", "佳", "仇", "臘", "窩", "滌", "劍", "瞧", "堡", "潑", "蔥", "罩", "霍", "撈", "胎", "蒼", "濱", "倆", "捅", "湘", "砍", "霞", "邵", "萄", "瘋", "淮", "遂", "熊", "糞", "烘", "宿", "檔", "戈", "駁", "嫂", "裕", "徙", "箭", "捐", "腸", "撐", "曬", "辨", "殿", "蓮", "攤", "攪", "醬", "屏", "疫", "哀", "蔡", "堵", "沫", "皺", "暢", "疊", "閣", "萊", "敲", "轄", "鉤", "痕", "壩", "巷", "餓", "禍", "丘", "玄", "溜", "曰", "邏", "彭", "嘗", "卿", "妨", "艇", "吞", "韋", "怨", "矮", "歇" };
 
+        /// <summary>
+        /// Chinese Traditional Constructor
+        /// </summary>
         public ChineseTraditional() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Korean Words
+    /// </summary>
     public class Korean : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "가격", "가끔", "가난", "가능", "가득", "가르침", "가뭄", "가방", "가상", "가슴", "가운데", "가을", "가이드", "가입", "가장", "가정", "가족", "가죽", "각오", "각자", "간격", "간부", "간섭", "간장", "간접", "간판", "갈등", "갈비", "갈색", "갈증", "감각", "감기", "감소", "감수성", "감자", "감정", "갑자기", "강남", "강당", "강도", "강력히", "강변", "강북", "강사", "강수량", "강아지", "강원도", "강의", "강제", "강조", "같이", "개구리", "개나리", "개방", "개별", "개선", "개성", "개인", "객관적", "거실", "거액", "거울", "거짓", "거품", "걱정", "건강", "건물", "건설", "건조", "건축", "걸음", "검사", "검토", "게시판", "게임", "겨울", "견해", "결과", "결국", "결론", "결석", "결승", "결심", "결정", "결혼", "경계", "경고", "경기", "경력", "경복궁", "경비", "경상도", "경영", "경우", "경쟁", "경제", "경주", "경찰", "경치", "경향", "경험", "계곡", "계단", "계란", "계산", "계속", "계약", "계절", "계층", "계획", "고객", "고구려", "고궁", "고급", "고등학생", "고무신", "고민", "고양이", "고장", "고전", "고집", "고춧가루", "고통", "고향", "곡식", "골목", "골짜기", "골프", "공간", "공개", "공격", "공군", "공급", "공기", "공동", "공무원", "공부", "공사", "공식", "공업", "공연", "공원", "공장", "공짜", "공책", "공통", "공포", "공항", "공휴일", "과목", "과일", "과장", "과정", "과학", "관객", "관계", "관광", "관념", "관람", "관련", "관리", "관습", "관심", "관점", "관찰", "광경", "광고", "광장", "광주", "괴로움", "굉장히", "교과서", "교문", "교복", "교실", "교양", "교육", "교장", "교직", "교통", "교환", "교훈", "구경", "구름", "구멍", "구별", "구분", "구석", "구성", "구속", "구역", "구입", "구청", "구체적", "국가", "국기", "국내", "국립", "국물", "국민", "국수", "국어", "국왕", "국적", "국제", "국회", "군대", "군사", "군인", "궁극적", "권리", "권위", "권투", "귀국", "귀신", "규정", "규칙", "균형", "그날", "그냥", "그늘", "그러나", "그룹", "그릇", "그림", "그제서야", "그토록", "극복", "극히", "근거", "근교", "근래", "근로", "근무", "근본", "근원", "근육", "근처", "글씨", "글자", "금강산", "금고", "금년", "금메달", "금액", "금연", "금요일", "금지", "긍정적", "기간", "기관", "기념", "기능", "기독교", "기둥", "기록", "기름", "기법", "기본", "기분", "기쁨", "기숙사", "기술", "기억", "기업", "기온", "기운", "기원", "기적", "기준", "기침", "기혼", "기획", "긴급", "긴장", "길이", "김밥", "김치", "김포공항", "깍두기", "깜빡", "깨달음", "깨소금", "껍질", "꼭대기", "꽃잎", "나들이", "나란히", "나머지", "나물", "나침반", "나흘", "낙엽", "난방", "날개", "날씨", "날짜", "남녀", "남대문", "남매", "남산", "남자", "남편", "남학생", "낭비", "낱말", "내년", "내용", "내일", "냄비", "냄새", "냇물", "냉동", "냉면", "냉방", "냉장고", "넥타이", "넷째", "노동", "노란색", "노력", "노인", "녹음", "녹차", "녹화", "논리", "논문", "논쟁", "놀이", "농구", "농담", "농민", "농부", "농업", "농장", "농촌", "높이", "눈동자", "눈물", "눈썹", "뉴욕", "느낌", "늑대", "능동적", "능력", "다방", "다양성", "다음", "다이어트", "다행", "단계", "단골", "단독", "단맛", "단순", "단어", "단위", "단점", "단체", "단추", "단편", "단풍", "달걀", "달러", "달력", "달리", "닭고기", "담당", "담배", "담요", "담임", "답변", "답장", "당근", "당분간", "당연히", "당장", "대규모", "대낮", "대단히", "대답", "대도시", "대략", "대량", "대륙", "대문", "대부분", "대신", "대응", "대장", "대전", "대접", "대중", "대책", "대출", "대충", "대통령", "대학", "대한민국", "대합실", "대형", "덩어리", "데이트", "도대체", "도덕", "도둑", "도망", "도서관", "도심", "도움", "도입", "도자기", "도저히", "도전", "도중", "도착", "독감", "독립", "독서", "독일", "독창적", "동화책", "뒷모습", "뒷산", "딸아이", "마누라", "마늘", "마당", "마라톤", "마련", "마무리", "마사지", "마약", "마요네즈", "마을", "마음", "마이크", "마중", "마지막", "마찬가지", "마찰", "마흔", "막걸리", "막내", "막상", "만남", "만두", "만세", "만약", "만일", "만점", "만족", "만화", "많이", "말기", "말씀", "말투", "맘대로", "망원경", "매년", "매달", "매력", "매번", "매스컴", "매일", "매장", "맥주", "먹이", "먼저", "먼지", "멀리", "메일", "며느리", "며칠", "면담", "멸치", "명단", "명령", "명예", "명의", "명절", "명칭", "명함", "모금", "모니터", "모델", "모든", "모범", "모습", "모양", "모임", "모조리", "모집", "모퉁이", "목걸이", "목록", "목사", "목소리", "목숨", "목적", "목표", "몰래", "몸매", "몸무게", "몸살", "몸속", "몸짓", "몸통", "몹시", "무관심", "무궁화", "무더위", "무덤", "무릎", "무슨", "무엇", "무역", "무용", "무조건", "무지개", "무척", "문구", "문득", "문법", "문서", "문제", "문학", "문화", "물가", "물건", "물결", "물고기", "물론", "물리학", "물음", "물질", "물체", "미국", "미디어", "미사일", "미술", "미역", "미용실", "미움", "미인", "미팅", "미혼", "민간", "민족", "민주", "믿음", "밀가루", "밀리미터", "밑바닥", "바가지", "바구니", "바나나", "바늘", "바닥", "바닷가", "바람", "바이러스", "바탕", "박물관", "박사", "박수", "반대", "반드시", "반말", "반발", "반성", "반응", "반장", "반죽", "반지", "반찬", "받침", "발가락", "발걸음", "발견", "발달", "발레", "발목", "발바닥", "발생", "발음", "발자국", "발전", "발톱", "발표", "밤하늘", "밥그릇", "밥맛", "밥상", "밥솥", "방금", "방면", "방문", "방바닥", "방법", "방송", "방식", "방안", "방울", "방지", "방학", "방해", "방향", "배경", "배꼽", "배달", "배드민턴", "백두산", "백색", "백성", "백인", "백제", "백화점", "버릇", "버섯", "버튼", "번개", "번역", "번지", "번호", "벌금", "벌레", "벌써", "범위", "범인", "범죄", "법률", "법원", "법적", "법칙", "베이징", "벨트", "변경", "변동", "변명", "변신", "변호사", "변화", "별도", "별명", "별일", "병실", "병아리", "병원", "보관", "보너스", "보라색", "보람", "보름", "보상", "보안", "보자기", "보장", "보전", "보존", "보통", "보편적", "보험", "복도", "복사", "복숭아", "복습", "볶음", "본격적", "본래", "본부", "본사", "본성", "본인", "본질", "볼펜", "봉사", "봉지", "봉투", "부근", "부끄러움", "부담", "부동산", "부문", "부분", "부산", "부상", "부엌", "부인", "부작용", "부장", "부정", "부족", "부지런히", "부친", "부탁", "부품", "부회장", "북부", "북한", "분노", "분량", "분리", "분명", "분석", "분야", "분위기", "분필", "분홍색", "불고기", "불과", "불교", "불꽃", "불만", "불법", "불빛", "불안", "불이익", "불행", "브랜드", "비극", "비난", "비닐", "비둘기", "비디오", "비로소", "비만", "비명", "비밀", "비바람", "비빔밥", "비상", "비용", "비율", "비중", "비타민", "비판", "빌딩", "빗물", "빗방울", "빗줄기", "빛깔", "빨간색", "빨래", "빨리", "사건", "사계절", "사나이", "사냥", "사람", "사랑", "사립", "사모님", "사물", "사방", "사상", "사생활", "사설", "사슴", "사실", "사업", "사용", "사월", "사장", "사전", "사진", "사촌", "사춘기", "사탕", "사투리", "사흘", "산길", "산부인과", "산업", "산책", "살림", "살인", "살짝", "삼계탕", "삼국", "삼십", "삼월", "삼촌", "상관", "상금", "상대", "상류", "상반기", "상상", "상식", "상업", "상인", "상자", "상점", "상처", "상추", "상태", "상표", "상품", "상황", "새벽", "색깔", "색연필", "생각", "생명", "생물", "생방송", "생산", "생선", "생신", "생일", "생활", "서랍", "서른", "서명", "서민", "서비스", "서양", "서울", "서적", "서점", "서쪽", "서클", "석사", "석유", "선거", "선물", "선배", "선생", "선수", "선원", "선장", "선전", "선택", "선풍기", "설거지", "설날", "설렁탕", "설명", "설문", "설사", "설악산", "설치", "설탕", "섭씨", "성공", "성당", "성명", "성별", "성인", "성장", "성적", "성질", "성함", "세금", "세미나", "세상", "세월", "세종대왕", "세탁", "센터", "센티미터", "셋째", "소규모", "소극적", "소금", "소나기", "소년", "소득", "소망", "소문", "소설", "소속", "소아과", "소용", "소원", "소음", "소중히", "소지품", "소질", "소풍", "소형", "속담", "속도", "속옷", "손가락", "손길", "손녀", "손님", "손등", "손목", "손뼉", "손실", "손질", "손톱", "손해", "솔직히", "솜씨", "송아지", "송이", "송편", "쇠고기", "쇼핑", "수건", "수년", "수단", "수돗물", "수동적", "수면", "수명", "수박", "수상", "수석", "수술", "수시로", "수업", "수염", "수영", "수입", "수준", "수집", "수출", "수컷", "수필", "수학", "수험생", "수화기", "숙녀", "숙소", "숙제", "순간", "순서", "순수", "순식간", "순위", "숟가락", "술병", "술집", "숫자", "스님", "스물", "스스로", "스승", "스웨터", "스위치", "스케이트", "스튜디오", "스트레스", "스포츠", "슬쩍", "슬픔", "습관", "습기", "승객", "승리", "승부", "승용차", "승진", "시각", "시간", "시골", "시금치", "시나리오", "시댁", "시리즈", "시멘트", "시민", "시부모", "시선", "시설", "시스템", "시아버지", "시어머니", "시월", "시인", "시일", "시작", "시장", "시절", "시점", "시중", "시즌", "시집", "시청", "시합", "시험", "식구", "식기", "식당", "식량", "식료품", "식물", "식빵", "식사", "식생활", "식초", "식탁", "식품", "신고", "신규", "신념", "신문", "신발", "신비", "신사", "신세", "신용", "신제품", "신청", "신체", "신화", "실감", "실내", "실력", "실례", "실망", "실수", "실습", "실시", "실장", "실정", "실질적", "실천", "실체", "실컷", "실태", "실패", "실험", "실현", "심리", "심부름", "심사", "심장", "심정", "심판", "쌍둥이", "씨름", "씨앗", "아가씨", "아나운서", "아드님", "아들", "아쉬움", "아스팔트", "아시아", "아울러", "아저씨", "아줌마", "아직", "아침", "아파트", "아프리카", "아픔", "아홉", "아흔", "악기", "악몽", "악수", "안개", "안경", "안과", "안내", "안녕", "안동", "안방", "안부", "안주", "알루미늄", "알코올", "암시", "암컷", "압력", "앞날", "앞문", "애인", "애정", "액수", "앨범", "야간", "야단", "야옹", "약간", "약국", "약속", "약수", "약점", "약품", "약혼녀", "양념", "양력", "양말", "양배추", "양주", "양파", "어둠", "어려움", "어른", "어젯밤", "어쨌든", "어쩌다가", "어쩐지", "언니", "언덕", "언론", "언어", "얼굴", "얼른", "얼음", "얼핏", "엄마", "업무", "업종", "업체", "엉덩이", "엉망", "엉터리", "엊그제", "에너지", "에어컨", "엔진", "여건", "여고생", "여관", "여군", "여권", "여대생", "여덟", "여동생", "여든", "여론", "여름", "여섯", "여성", "여왕", "여인", "여전히", "여직원", "여학생", "여행", "역사", "역시", "역할", "연결", "연구", "연극", "연기", "연락", "연설", "연세", "연속", "연습", "연애", "연예인", "연인", "연장", "연주", "연출", "연필", "연합", "연휴", "열기", "열매", "열쇠", "열심히", "열정", "열차", "열흘", "염려", "엽서", "영국", "영남", "영상", "영양", "영역", "영웅", "영원히", "영하", "영향", "영혼", "영화", "옆구리", "옆방", "옆집", "예감", "예금", "예방", "예산", "예상", "예선", "예술", "예습", "예식장", "예약", "예전", "예절", "예정", "예컨대", "옛날", "오늘", "오락", "오랫동안", "오렌지", "오로지", "오른발", "오븐", "오십", "오염", "오월", "오전", "오직", "오징어", "오페라", "오피스텔", "오히려", "옥상", "옥수수", "온갖", "온라인", "온몸", "온종일", "온통", "올가을", "올림픽", "올해", "옷차림", "와이셔츠", "와인", "완성", "완전", "왕비", "왕자", "왜냐하면", "왠지", "외갓집", "외국", "외로움", "외삼촌", "외출", "외침", "외할머니", "왼발", "왼손", "왼쪽", "요금", "요일", "요즘", "요청", "용기", "용서", "용어", "우산", "우선", "우승", "우연히", "우정", "우체국", "우편", "운동", "운명", "운반", "운전", "운행", "울산", "울음", "움직임", "웃어른", "웃음", "워낙", "원고", "원래", "원서", "원숭이", "원인", "원장", "원피스", "월급", "월드컵", "월세", "월요일", "웨이터", "위반", "위법", "위성", "위원", "위험", "위협", "윗사람", "유난히", "유럽", "유명", "유물", "유산", "유적", "유치원", "유학", "유행", "유형", "육군", "육상", "육십", "육체", "은행", "음력", "음료", "음반", "음성", "음식", "음악", "음주", "의견", "의논", "의문", "의복", "의식", "의심", "의외로", "의욕", "의원", "의학", "이것", "이곳", "이념", "이놈", "이달", "이대로", "이동", "이렇게", "이력서", "이론적", "이름", "이민", "이발소", "이별", "이불", "이빨", "이상", "이성", "이슬", "이야기", "이용", "이웃", "이월", "이윽고", "이익", "이전", "이중", "이튿날", "이틀", "이혼", "인간", "인격", "인공", "인구", "인근", "인기", "인도", "인류", "인물", "인생", "인쇄", "인연", "인원", "인재", "인종", "인천", "인체", "인터넷", "인하", "인형", "일곱", "일기", "일단", "일대", "일등", "일반", "일본", "일부", "일상", "일생", "일손", "일요일", "일월", "일정", "일종", "일주일", "일찍", "일체", "일치", "일행", "일회용", "임금", "임무", "입대", "입력", "입맛", "입사", "입술", "입시", "입원", "입장", "입학", "자가용", "자격", "자극", "자동", "자랑", "자부심", "자식", "자신", "자연", "자원", "자율", "자전거", "자정", "자존심", "자판", "작가", "작년", "작성", "작업", "작용", "작은딸", "작품", "잔디", "잔뜩", "잔치", "잘못", "잠깐", "잠수함", "잠시", "잠옷", "잠자리", "잡지", "장관", "장군", "장기간", "장래", "장례", "장르", "장마", "장면", "장모", "장미", "장비", "장사", "장소", "장식", "장애인", "장인", "장점", "장차", "장학금", "재능", "재빨리", "재산", "재생", "재작년", "재정", "재채기", "재판", "재학", "재활용", "저것", "저고리", "저곳", "저녁", "저런", "저렇게", "저번", "저울", "저절로", "저축", "적극", "적당히", "적성", "적용", "적응", "전개", "전공", "전기", "전달", "전라도", "전망", "전문", "전반", "전부", "전세", "전시", "전용", "전자", "전쟁", "전주", "전철", "전체", "전통", "전혀", "전후", "절대", "절망", "절반", "절약", "절차", "점검", "점수", "점심", "점원", "점점", "점차", "접근", "접시", "접촉", "젓가락", "정거장", "정도", "정류장", "정리", "정말", "정면", "정문", "정반대", "정보", "정부", "정비", "정상", "정성", "정오", "정원", "정장", "정지", "정치", "정확히", "제공", "제과점", "제대로", "제목", "제발", "제법", "제삿날", "제안", "제일", "제작", "제주도", "제출", "제품", "제한", "조각", "조건", "조금", "조깅", "조명", "조미료", "조상", "조선", "조용히", "조절", "조정", "조직", "존댓말", "존재", "졸업", "졸음", "종교", "종로", "종류", "종소리", "종업원", "종종", "종합", "좌석", "죄인", "주관적", "주름", "주말", "주머니", "주먹", "주문", "주민", "주방", "주변", "주식", "주인", "주일", "주장", "주전자", "주택", "준비", "줄거리", "줄기", "줄무늬", "중간", "중계방송", "중국", "중년", "중단", "중독", "중반", "중부", "중세", "중소기업", "중순", "중앙", "중요", "중학교", "즉석", "즉시", "즐거움", "증가", "증거", "증권", "증상", "증세", "지각", "지갑", "지경", "지극히", "지금", "지급", "지능", "지름길", "지리산", "지방", "지붕", "지식", "지역", "지우개", "지원", "지적", "지점", "지진", "지출", "직선", "직업", "직원", "직장", "진급", "진동", "진로", "진료", "진리", "진짜", "진찰", "진출", "진통", "진행", "질문", "질병", "질서", "짐작", "집단", "집안", "집중", "짜증", "찌꺼기", "차남", "차라리", "차량", "차림", "차별", "차선", "차츰", "착각", "찬물", "찬성", "참가", "참기름", "참새", "참석", "참여", "참외", "참조", "찻잔", "창가", "창고", "창구", "창문", "창밖", "창작", "창조", "채널", "채점", "책가방", "책방", "책상", "책임", "챔피언", "처벌", "처음", "천국", "천둥", "천장", "천재", "천천히", "철도", "철저히", "철학", "첫날", "첫째", "청년", "청바지", "청소", "청춘", "체계", "체력", "체온", "체육", "체중", "체험", "초등학생", "초반", "초밥", "초상화", "초순", "초여름", "초원", "초저녁", "초점", "초청", "초콜릿", "촛불", "총각", "총리", "총장", "촬영", "최근", "최상", "최선", "최신", "최악", "최종", "추석", "추억", "추진", "추천", "추측", "축구", "축소", "축제", "축하", "출근", "출발", "출산", "출신", "출연", "출입", "출장", "출판", "충격", "충고", "충돌", "충분히", "충청도", "취업", "취직", "취향", "치약", "친구", "친척", "칠십", "칠월", "칠판", "침대", "침묵", "침실", "칫솔", "칭찬", "카메라", "카운터", "칼국수", "캐릭터", "캠퍼스", "캠페인", "커튼", "컨디션", "컬러", "컴퓨터", "코끼리", "코미디", "콘서트", "콜라", "콤플렉스", "콩나물", "쾌감", "쿠데타", "크림", "큰길", "큰딸", "큰소리", "큰아들", "큰어머니", "큰일", "큰절", "클래식", "클럽", "킬로", "타입", "타자기", "탁구", "탁자", "탄생", "태권도", "태양", "태풍", "택시", "탤런트", "터널", "터미널", "테니스", "테스트", "테이블", "텔레비전", "토론", "토마토", "토요일", "통계", "통과", "통로", "통신", "통역", "통일", "통장", "통제", "통증", "통합", "통화", "퇴근", "퇴원", "퇴직금", "튀김", "트럭", "특급", "특별", "특성", "특수", "특징", "특히", "튼튼히", "티셔츠", "파란색", "파일", "파출소", "판결", "판단", "판매", "판사", "팔십", "팔월", "팝송", "패션", "팩스", "팩시밀리", "팬티", "퍼센트", "페인트", "편견", "편의", "편지", "편히", "평가", "평균", "평생", "평소", "평양", "평일", "평화", "포스터", "포인트", "포장", "포함", "표면", "표정", "표준", "표현", "품목", "품질", "풍경", "풍속", "풍습", "프랑스", "프린터", "플라스틱", "피곤", "피망", "피아노", "필름", "필수", "필요", "필자", "필통", "핑계", "하느님", "하늘", "하드웨어", "하룻밤", "하반기", "하숙집", "하순", "하여튼", "하지만", "하천", "하품", "하필", "학과", "학교", "학급", "학기", "학년", "학력", "학번", "학부모", "학비", "학생", "학술", "학습", "학용품", "학원", "학위", "학자", "학점", "한계", "한글", "한꺼번에", "한낮", "한눈", "한동안", "한때", "한라산", "한마디", "한문", "한번", "한복", "한식", "한여름", "한쪽", "할머니", "할아버지", "할인", "함께", "함부로", "합격", "합리적", "항공", "항구", "항상", "항의", "해결", "해군", "해답", "해당", "해물", "해석", "해설", "해수욕장", "해안", "핵심", "핸드백", "햄버거", "햇볕", "햇살", "행동", "행복", "행사", "행운", "행위", "향기", "향상", "향수", "허락", "허용", "헬기", "현관", "현금", "현대", "현상", "현실", "현장", "현재", "현지", "혈액", "협력", "형부", "형사", "형수", "형식", "형제", "형태", "형편", "혜택", "호기심", "호남", "호랑이", "호박", "호텔", "호흡", "혹시", "홀로", "홈페이지", "홍보", "홍수", "홍차", "화면", "화분", "화살", "화요일", "화장", "화학", "확보", "확인", "확장", "확정", "환갑", "환경", "환영", "환율", "환자", "활기", "활동", "활발히", "활용", "활짝", "회견", "회관", "회복", "회색", "회원", "회장", "회전", "횟수", "횡단보도", "효율적", "후반", "후춧가루", "훈련", "훨씬", "휴식", "휴일", "흉내", "흐름", "흑백", "흑인", "흔적", "흔히", "흥미", "흥분", "희곡", "희망", "희생", "흰색", "힘껏" };
 
+        /// <summary>
+        /// Korean Constructor
+        /// </summary>
         public Korean() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// English Words
+    /// </summary>
     public class English : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract", "absurd", "abuse", "access", "accident", "account", "accuse", "achieve", "acid", "acoustic", "acquire", "across", "act", "action", "actor", "actress", "actual", "adapt", "add", "addict", "address", "adjust", "admit", "adult", "advance", "advice", "aerobic", "affair", "afford", "afraid", "again", "age", "agent", "agree", "ahead", "aim", "air", "airport", "aisle", "alarm", "album", "alcohol", "alert", "alien", "all", "alley", "allow", "almost", "alone", "alpha", "already", "also", "alter", "always", "amateur", "amazing", "among", "amount", "amused", "analyst", "anchor", "ancient", "anger", "angle", "angry", "animal", "ankle", "announce", "annual", "another", "answer", "antenna", "antique", "anxiety", "any", "apart", "apology", "appear", "apple", "approve", "april", "arch", "arctic", "area", "arena", "argue", "arm", "armed", "armor", "army", "around", "arrange", "arrest", "arrive", "arrow", "art", "artefact", "artist", "artwork", "ask", "aspect", "assault", "asset", "assist", "assume", "asthma", "athlete", "atom", "attack", "attend", "attitude", "attract", "auction", "audit", "august", "aunt", "author", "auto", "autumn", "average", "avocado", "avoid", "awake", "aware", "away", "awesome", "awful", "awkward", "axis", "baby", "bachelor", "bacon", "badge", "bag", "balance", "balcony", "ball", "bamboo", "banana", "banner", "bar", "barely", "bargain", "barrel", "base", "basic", "basket", "battle", "beach", "bean", "beauty", "because", "become", "beef", "before", "begin", "behave", "behind", "believe", "below", "belt", "bench", "benefit", "best", "betray", "better", "between", "beyond", "bicycle", "bid", "bike", "bind", "biology", "bird", "birth", "bitter", "black", "blade", "blame", "blanket", "blast", "bleak", "bless", "blind", "blood", "blossom", "blouse", "blue", "blur", "blush", "board", "boat", "body", "boil", "bomb", "bone", "bonus", "book", "boost", "border", "boring", "borrow", "boss", "bottom", "bounce", "box", "boy", "bracket", "brain", "brand", "brass", "brave", "bread", "breeze", "brick", "bridge", "brief", "bright", "bring", "brisk", "broccoli", "broken", "bronze", "broom", "brother", "brown", "brush", "bubble", "buddy", "budget", "buffalo", "build", "bulb", "bulk", "bullet", "bundle", "bunker", "burden", "burger", "burst", "bus", "business", "busy", "butter", "buyer", "buzz", "cabbage", "cabin", "cable", "cactus", "cage", "cake", "call", "calm", "camera", "camp", "can", "canal", "cancel", "candy", "cannon", "canoe", "canvas", "canyon", "capable", "capital", "captain", "car", "carbon", "card", "cargo", "carpet", "carry", "cart", "case", "cash", "casino", "castle", "casual", "cat", "catalog", "catch", "category", "cattle", "caught", "cause", "caution", "cave", "ceiling", "celery", "cement", "census", "century", "cereal", "certain", "chair", "chalk", "champion", "change", "chaos", "chapter", "charge", "chase", "chat", "cheap", "check", "cheese", "chef", "cherry", "chest", "chicken", "chief", "child", "chimney", "choice", "choose", "chronic", "chuckle", "chunk", "churn", "cigar", "cinnamon", "circle", "citizen", "city", "civil", "claim", "clap", "clarify", "claw", "clay", "clean", "clerk", "clever", "click", "client", "cliff", "climb", "clinic", "clip", "clock", "clog", "close", "cloth", "cloud", "clown", "club", "clump", "cluster", "clutch", "coach", "coast", "coconut", "code", "coffee", "coil", "coin", "collect", "color", "column", "combine", "come", "comfort", "comic", "common", "company", "concert", "conduct", "confirm", "congress", "connect", "consider", "control", "convince", "cook", "cool", "copper", "copy", "coral", "core", "corn", "correct", "cost", "cotton", "couch", "country", "couple", "course", "cousin", "cover", "coyote", "crack", "cradle", "craft", "cram", "crane", "crash", "crater", "crawl", "crazy", "cream", "credit", "creek", "crew", "cricket", "crime", "crisp", "critic", "crop", "cross", "crouch", "crowd", "crucial", "cruel", "cruise", "crumble", "crunch", "crush", "cry", "crystal", "cube", "culture", "cup", "cupboard", "curious", "current", "curtain", "curve", "cushion", "custom", "cute", "cycle", "dad", "damage", "damp", "dance", "danger", "daring", "dash", "daughter", "dawn", "day", "deal", "debate", "debris", "decade", "december", "decide", "decline", "decorate", "decrease", "deer", "defense", "define", "defy", "degree", "delay", "deliver", "demand", "demise", "denial", "dentist", "deny", "depart", "depend", "deposit", "depth", "deputy", "derive", "describe", "desert", "design", "desk", "despair", "destroy", "detail", "detect", "develop", "device", "devote", "diagram", "dial", "diamond", "diary", "dice", "diesel", "diet", "differ", "digital", "dignity", "dilemma", "dinner", "dinosaur", "direct", "dirt", "disagree", "discover", "disease", "dish", "dismiss", "disorder", "display", "distance", "divert", "divide", "divorce", "dizzy", "doctor", "document", "dog", "doll", "dolphin", "domain", "donate", "donkey", "donor", "door", "dose", "double", "dove", "draft", "dragon", "drama", "drastic", "draw", "dream", "dress", "drift", "drill", "drink", "drip", "drive", "drop", "drum", "dry", "duck", "dumb", "dune", "during", "dust", "dutch", "duty", "dwarf", "dynamic", "eager", "eagle", "early", "earn", "earth", "easily", "east", "easy", "echo", "ecology", "economy", "edge", "edit", "educate", "effort", "egg", "eight", "either", "elbow", "elder", "electric", "elegant", "element", "elephant", "elevator", "elite", "else", "embark", "embody", "embrace", "emerge", "emotion", "employ", "empower", "empty", "enable", "enact", "end", "endless", "endorse", "enemy", "energy", "enforce", "engage", "engine", "enhance", "enjoy", "enlist", "enough", "enrich", "enroll", "ensure", "enter", "entire", "entry", "envelope", "episode", "equal", "equip", "era", "erase", "erode", "erosion", "error", "erupt", "escape", "essay", "essence", "estate", "eternal", "ethics", "evidence", "evil", "evoke", "evolve", "exact", "example", "excess", "exchange", "excite", "exclude", "excuse", "execute", "exercise", "exhaust", "exhibit", "exile", "exist", "exit", "exotic", "expand", "expect", "expire", "explain", "expose", "express", "extend", "extra", "eye", "eyebrow", "fabric", "face", "faculty", "fade", "faint", "faith", "fall", "false", "fame", "family", "famous", "fan", "fancy", "fantasy", "farm", "fashion", "fat", "fatal", "father", "fatigue", "fault", "favorite", "feature", "february", "federal", "fee", "feed", "feel", "female", "fence", "festival", "fetch", "fever", "few", "fiber", "fiction", "field", "figure", "file", "film", "filter", "final", "find", "fine", "finger", "finish", "fire", "firm", "first", "fiscal", "fish", "fit", "fitness", "fix", "flag", "flame", "flash", "flat", "flavor", "flee", "flight", "flip", "float", "flock", "floor", "flower", "fluid", "flush", "fly", "foam", "focus", "fog", "foil", "fold", "follow", "food", "foot", "force", "forest", "forget", "fork", "fortune", "forum", "forward", "fossil", "foster", "found", "fox", "fragile", "frame", "frequent", "fresh", "friend", "fringe", "frog", "front", "frost", "frown", "frozen", "fruit", "fuel", "fun", "funny", "furnace", "fury", "future", "gadget", "gain", "galaxy", "gallery", "game", "gap", "garage", "garbage", "garden", "garlic", "garment", "gas", "gasp", "gate", "gather", "gauge", "gaze", "general", "genius", "genre", "gentle", "genuine", "gesture", "ghost", "giant", "gift", "giggle", "ginger", "giraffe", "girl", "give", "glad", "glance", "glare", "glass", "glide", "glimpse", "globe", "gloom", "glory", "glove", "glow", "glue", "goat", "goddess", "gold", "good", "goose", "gorilla", "gospel", "gossip", "govern", "gown", "grab", "grace", "grain", "grant", "grape", "grass", "gravity", "great", "green", "grid", "grief", "grit", "grocery", "group", "grow", "grunt", "guard", "guess", "guide", "guilt", "guitar", "gun", "gym", "habit", "hair", "half", "hammer", "hamster", "hand", "happy", "harbor", "hard", "harsh", "harvest", "hat", "have", "hawk", "hazard", "head", "health", "heart", "heavy", "hedgehog", "height", "hello", "helmet", "help", "hen", "hero", "hidden", "high", "hill", "hint", "hip", "hire", "history", "hobby", "hockey", "hold", "hole", "holiday", "hollow", "home", "honey", "hood", "hope", "horn", "horror", "horse", "hospital", "host", "hotel", "hour", "hover", "hub", "huge", "human", "humble", "humor", "hundred", "hungry", "hunt", "hurdle", "hurry", "hurt", "husband", "hybrid", "ice", "icon", "idea", "identify", "idle", "ignore", "ill", "illegal", "illness", "image", "imitate", "immense", "immune", "impact", "impose", "improve", "impulse", "inch", "include", "income", "increase", "index", "indicate", "indoor", "industry", "infant", "inflict", "inform", "inhale", "inherit", "initial", "inject", "injury", "inmate", "inner", "innocent", "input", "inquiry", "insane", "insect", "inside", "inspire", "install", "intact", "interest", "into", "invest", "invite", "involve", "iron", "island", "isolate", "issue", "item", "ivory", "jacket", "jaguar", "jar", "jazz", "jealous", "jeans", "jelly", "jewel", "job", "join", "joke", "journey", "joy", "judge", "juice", "jump", "jungle", "junior", "junk", "just", "kangaroo", "keen", "keep", "ketchup", "key", "kick", "kid", "kidney", "kind", "kingdom", "kiss", "kit", "kitchen", "kite", "kitten", "kiwi", "knee", "knife", "knock", "know", "lab", "label", "labor", "ladder", "lady", "lake", "lamp", "language", "laptop", "large", "later", "latin", "laugh", "laundry", "lava", "law", "lawn", "lawsuit", "layer", "lazy", "leader", "leaf", "learn", "leave", "lecture", "left", "leg", "legal", "legend", "leisure", "lemon", "lend", "length", "lens", "leopard", "lesson", "letter", "level", "liar", "liberty", "library", "license", "life", "lift", "light", "like", "limb", "limit", "link", "lion", "liquid", "list", "little", "live", "lizard", "load", "loan", "lobster", "local", "lock", "logic", "lonely", "long", "loop", "lottery", "loud", "lounge", "love", "loyal", "lucky", "luggage", "lumber", "lunar", "lunch", "luxury", "lyrics", "machine", "mad", "magic", "magnet", "maid", "mail", "main", "major", "make", "mammal", "man", "manage", "mandate", "mango", "mansion", "manual", "maple", "marble", "march", "margin", "marine", "market", "marriage", "mask", "mass", "master", "match", "material", "math", "matrix", "matter", "maximum", "maze", "meadow", "mean", "measure", "meat", "mechanic", "medal", "media", "melody", "melt", "member", "memory", "mention", "menu", "mercy", "merge", "merit", "merry", "mesh", "message", "metal", "method", "middle", "midnight", "milk", "million", "mimic", "mind", "minimum", "minor", "minute", "miracle", "mirror", "misery", "miss", "mistake", "mix", "mixed", "mixture", "mobile", "model", "modify", "mom", "moment", "monitor", "monkey", "monster", "month", "moon", "moral", "more", "morning", "mosquito", "mother", "motion", "motor", "mountain", "mouse", "move", "movie", "much", "muffin", "mule", "multiply", "muscle", "museum", "mushroom", "music", "must", "mutual", "myself", "mystery", "myth", "naive", "name", "napkin", "narrow", "nasty", "nation", "nature", "near", "neck", "need", "negative", "neglect", "neither", "nephew", "nerve", "nest", "net", "network", "neutral", "never", "news", "next", "nice", "night", "noble", "noise", "nominee", "noodle", "normal", "north", "nose", "notable", "note", "nothing", "notice", "novel", "now", "nuclear", "number", "nurse", "nut", "oak", "obey", "object", "oblige", "obscure", "observe", "obtain", "obvious", "occur", "ocean", "october", "odor", "off", "offer", "office", "often", "oil", "okay", "old", "olive", "olympic", "omit", "once", "one", "onion", "online", "only", "open", "opera", "opinion", "oppose", "option", "orange", "orbit", "orchard", "order", "ordinary", "organ", "orient", "original", "orphan", "ostrich", "other", "outdoor", "outer", "output", "outside", "oval", "oven", "over", "own", "owner", "oxygen", "oyster", "ozone", "pact", "paddle", "page", "pair", "palace", "palm", "panda", "panel", "panic", "panther", "paper", "parade", "parent", "park", "parrot", "party", "pass", "patch", "path", "patient", "patrol", "pattern", "pause", "pave", "payment", "peace", "peanut", "pear", "peasant", "pelican", "pen", "penalty", "pencil", "people", "pepper", "perfect", "permit", "person", "pet", "phone", "photo", "phrase", "physical", "piano", "picnic", "picture", "piece", "pig", "pigeon", "pill", "pilot", "pink", "pioneer", "pipe", "pistol", "pitch", "pizza", "place", "planet", "plastic", "plate", "play", "please", "pledge", "pluck", "plug", "plunge", "poem", "poet", "point", "polar", "pole", "police", "pond", "pony", "pool", "popular", "portion", "position", "possible", "post", "potato", "pottery", "poverty", "powder", "power", "practice", "praise", "predict", "prefer", "prepare", "present", "pretty", "prevent", "price", "pride", "primary", "print", "priority", "prison", "private", "prize", "problem", "process", "produce", "profit", "program", "project", "promote", "proof", "property", "prosper", "protect", "proud", "provide", "public", "pudding", "pull", "pulp", "pulse", "pumpkin", "punch", "pupil", "puppy", "purchase", "purity", "purpose", "purse", "push", "put", "puzzle", "pyramid", "quality", "quantum", "quarter", "question", "quick", "quit", "quiz", "quote", "rabbit", "raccoon", "race", "rack", "radar", "radio", "rail", "rain", "raise", "rally", "ramp", "ranch", "random", "range", "rapid", "rare", "rate", "rather", "raven", "raw", "razor", "ready", "real", "reason", "rebel", "rebuild", "recall", "receive", "recipe", "record", "recycle", "reduce", "reflect", "reform", "refuse", "region", "regret", "regular", "reject", "relax", "release", "relief", "rely", "remain", "remember", "remind", "remove", "render", "renew", "rent", "reopen", "repair", "repeat", "replace", "report", "require", "rescue", "resemble", "resist", "resource", "response", "result", "retire", "retreat", "return", "reunion", "reveal", "review", "reward", "rhythm", "rib", "ribbon", "rice", "rich", "ride", "ridge", "rifle", "right", "rigid", "ring", "riot", "ripple", "risk", "ritual", "rival", "river", "road", "roast", "robot", "robust", "rocket", "romance", "roof", "rookie", "room", "rose", "rotate", "rough", "round", "route", "royal", "rubber", "rude", "rug", "rule", "run", "runway", "rural", "sad", "saddle", "sadness", "safe", "sail", "salad", "salmon", "salon", "salt", "salute", "same", "sample", "sand", "satisfy", "satoshi", "sauce", "sausage", "save", "say", "scale", "scan", "scare", "scatter", "scene", "scheme", "school", "science", "scissors", "scorpion", "scout", "scrap", "screen", "script", "scrub", "sea", "search", "season", "seat", "second", "secret", "section", "security", "seed", "seek", "segment", "select", "sell", "seminar", "senior", "sense", "sentence", "series", "service", "session", "settle", "setup", "seven", "shadow", "shaft", "shallow", "share", "shed", "shell", "sheriff", "shield", "shift", "shine", "ship", "shiver", "shock", "shoe", "shoot", "shop", "short", "shoulder", "shove", "shrimp", "shrug", "shuffle", "shy", "sibling", "sick", "side", "siege", "sight", "sign", "silent", "silk", "silly", "silver", "similar", "simple", "since", "sing", "siren", "sister", "situate", "six", "size", "skate", "sketch", "ski", "skill", "skin", "skirt", "skull", "slab", "slam", "sleep", "slender", "slice", "slide", "slight", "slim", "slogan", "slot", "slow", "slush", "small", "smart", "smile", "smoke", "smooth", "snack", "snake", "snap", "sniff", "snow", "soap", "soccer", "social", "sock", "soda", "soft", "solar", "soldier", "solid", "solution", "solve", "someone", "song", "soon", "sorry", "sort", "soul", "sound", "soup", "source", "south", "space", "spare", "spatial", "spawn", "speak", "special", "speed", "spell", "spend", "sphere", "spice", "spider", "spike", "spin", "spirit", "split", "spoil", "sponsor", "spoon", "sport", "spot", "spray", "spread", "spring", "spy", "square", "squeeze", "squirrel", "stable", "stadium", "staff", "stage", "stairs", "stamp", "stand", "start", "state", "stay", "steak", "steel", "stem", "step", "stereo", "stick", "still", "sting", "stock", "stomach", "stone", "stool", "story", "stove", "strategy", "street", "strike", "strong", "struggle", "student", "stuff", "stumble", "style", "subject", "submit", "subway", "success", "such", "sudden", "suffer", "sugar", "suggest", "suit", "summer", "sun", "sunny", "sunset", "super", "supply", "supreme", "sure", "surface", "surge", "surprise", "surround", "survey", "suspect", "sustain", "swallow", "swamp", "swap", "swarm", "swear", "sweet", "swift", "swim", "swing", "switch", "sword", "symbol", "symptom", "syrup", "system", "table", "tackle", "tag", "tail", "talent", "talk", "tank", "tape", "target", "task", "taste", "tattoo", "taxi", "teach", "team", "tell", "ten", "tenant", "tennis", "tent", "term", "test", "text", "thank", "that", "theme", "then", "theory", "there", "they", "thing", "this", "thought", "three", "thrive", "throw", "thumb", "thunder", "ticket", "tide", "tiger", "tilt", "timber", "time", "tiny", "tip", "tired", "tissue", "title", "toast", "tobacco", "today", "toddler", "toe", "together", "toilet", "token", "tomato", "tomorrow", "tone", "tongue", "tonight", "tool", "tooth", "top", "topic", "topple", "torch", "tornado", "tortoise", "toss", "total", "tourist", "toward", "tower", "town", "toy", "track", "trade", "traffic", "tragic", "train", "transfer", "trap", "trash", "travel", "tray", "treat", "tree", "trend", "trial", "tribe", "trick", "trigger", "trim", "trip", "trophy", "trouble", "truck", "true", "truly", "trumpet", "trust", "truth", "try", "tube", "tuition", "tumble", "tuna", "tunnel", "turkey", "turn", "turtle", "twelve", "twenty", "twice", "twin", "twist", "two", "type", "typical", "ugly", "umbrella", "unable", "unaware", "uncle", "uncover", "under", "undo", "unfair", "unfold", "unhappy", "uniform", "unique", "unit", "universe", "unknown", "unlock", "until", "unusual", "unveil", "update", "upgrade", "uphold", "upon", "upper", "upset", "urban", "urge", "usage", "use", "used", "useful", "useless", "usual", "utility", "vacant", "vacuum", "vague", "valid", "valley", "valve", "van", "vanish", "vapor", "various", "vast", "vault", "vehicle", "velvet", "vendor", "venture", "venue", "verb", "verify", "version", "very", "vessel", "veteran", "viable", "vibrant", "vicious", "victory", "video", "view", "village", "vintage", "violin", "virtual", "virus", "visa", "visit", "visual", "vital", "vivid", "vocal", "voice", "void", "volcano", "volume", "vote", "voyage", "wage", "wagon", "wait", "walk", "wall", "walnut", "want", "warfare", "warm", "warrior", "wash", "wasp", "waste", "water", "wave", "way", "wealth", "weapon", "wear", "weasel", "weather", "web", "wedding", "weekend", "weird", "welcome", "west", "wet", "whale", "what", "wheat", "wheel", "when", "where", "whip", "whisper", "wide", "width", "wife", "wild", "will", "win", "window", "wine", "wing", "wink", "winner", "winter", "wire", "wisdom", "wise", "wish", "witness", "wolf", "woman", "wonder", "wood", "wool", "word", "work", "world", "worry", "worth", "wrap", "wreck", "wrestle", "wrist", "write", "wrong", "yard", "year", "yellow", "you", "young", "youth", "zebra", "zero", "zone", "zoo" };
 
+        /// <summary>
+        /// English Constructor
+        /// </summary>
         public English() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// French Words
+    /// </summary>
     public class French : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "abaisser", "abandon", "abdiquer", "abeille", "abolir", "aborder", "aboutir", "aboyer", "abrasif", "abreuver", "abriter", "abroger", "abrupt", "absence", "absolu", "absurde", "abusif", "abyssal", "académie", "acajou", "acarien", "accabler", "accepter", "acclamer", "accolade", "accroche", "accuser", "acerbe", "achat", "acheter", "aciduler", "acier", "acompte", "acquérir", "acronyme", "acteur", "actif", "actuel", "adepte", "adéquat", "adhésif", "adjectif", "adjuger", "admettre", "admirer", "adopter", "adorer", "adoucir", "adresse", "adroit", "adulte", "adverbe", "aérer", "aéronef", "affaire", "affecter", "affiche", "affreux", "affubler", "agacer", "agencer", "agile", "agiter", "agrafer", "agréable", "agrume", "aider", "aiguille", "ailier", "aimable", "aisance", "ajouter", "ajuster", "alarmer", "alchimie", "alerte", "algèbre", "algue", "aliéner", "aliment", "alléger", "alliage", "allouer", "allumer", "alourdir", "alpaga", "altesse", "alvéole", "amateur", "ambigu", "ambre", "aménager", "amertume", "amidon", "amiral", "amorcer", "amour", "amovible", "amphibie", "ampleur", "amusant", "analyse", "anaphore", "anarchie", "anatomie", "ancien", "anéantir", "angle", "angoisse", "anguleux", "animal", "annexer", "annonce", "annuel", "anodin", "anomalie", "anonyme", "anormal", "antenne", "antidote", "anxieux", "apaiser", "apéritif", "aplanir", "apologie", "appareil", "appeler", "apporter", "appuyer", "aquarium", "aqueduc", "arbitre", "arbuste", "ardeur", "ardoise", "argent", "arlequin", "armature", "armement", "armoire", "armure", "arpenter", "arracher", "arriver", "arroser", "arsenic", "artériel", "article", "aspect", "asphalte", "aspirer", "assaut", "asservir", "assiette", "associer", "assurer", "asticot", "astre", "astuce", "atelier", "atome", "atrium", "atroce", "attaque", "attentif", "attirer", "attraper", "aubaine", "auberge", "audace", "audible", "augurer", "aurore", "automne", "autruche", "avaler", "avancer", "avarice", "avenir", "averse", "aveugle", "aviateur", "avide", "avion", "aviser", "avoine", "avouer", "avril", "axial", "axiome", "badge", "bafouer", "bagage", "baguette", "baignade", "balancer", "balcon", "baleine", "balisage", "bambin", "bancaire", "bandage", "banlieue", "bannière", "banquier", "barbier", "baril", "baron", "barque", "barrage", "bassin", "bastion", "bataille", "bateau", "batterie", "baudrier", "bavarder", "belette", "bélier", "belote", "bénéfice", "berceau", "berger", "berline", "bermuda", "besace", "besogne", "bétail", "beurre", "biberon", "bicycle", "bidule", "bijou", "bilan", "bilingue", "billard", "binaire", "biologie", "biopsie", "biotype", "biscuit", "bison", "bistouri", "bitume", "bizarre", "blafard", "blague", "blanchir", "blessant", "blinder", "blond", "bloquer", "blouson", "bobard", "bobine", "boire", "boiser", "bolide", "bonbon", "bondir", "bonheur", "bonifier", "bonus", "bordure", "borne", "botte", "boucle", "boueux", "bougie", "boulon", "bouquin", "bourse", "boussole", "boutique", "boxeur", "branche", "brasier", "brave", "brebis", "brèche", "breuvage", "bricoler", "brigade", "brillant", "brioche", "brique", "brochure", "broder", "bronzer", "brousse", "broyeur", "brume", "brusque", "brutal", "bruyant", "buffle", "buisson", "bulletin", "bureau", "burin", "bustier", "butiner", "butoir", "buvable", "buvette", "cabanon", "cabine", "cachette", "cadeau", "cadre", "caféine", "caillou", "caisson", "calculer", "calepin", "calibre", "calmer", "calomnie", "calvaire", "camarade", "caméra", "camion", "campagne", "canal", "caneton", "canon", "cantine", "canular", "capable", "caporal", "caprice", "capsule", "capter", "capuche", "carabine", "carbone", "caresser", "caribou", "carnage", "carotte", "carreau", "carton", "cascade", "casier", "casque", "cassure", "causer", "caution", "cavalier", "caverne", "caviar", "cédille", "ceinture", "céleste", "cellule", "cendrier", "censurer", "central", "cercle", "cérébral", "cerise", "cerner", "cerveau", "cesser", "chagrin", "chaise", "chaleur", "chambre", "chance", "chapitre", "charbon", "chasseur", "chaton", "chausson", "chavirer", "chemise", "chenille", "chéquier", "chercher", "cheval", "chien", "chiffre", "chignon", "chimère", "chiot", "chlorure", "chocolat", "choisir", "chose", "chouette", "chrome", "chute", "cigare", "cigogne", "cimenter", "cinéma", "cintrer", "circuler", "cirer", "cirque", "citerne", "citoyen", "citron", "civil", "clairon", "clameur", "claquer", "classe", "clavier", "client", "cligner", "climat", "clivage", "cloche", "clonage", "cloporte", "cobalt", "cobra", "cocasse", "cocotier", "coder", "codifier", "coffre", "cogner", "cohésion", "coiffer", "coincer", "colère", "colibri", "colline", "colmater", "colonel", "combat", "comédie", "commande", "compact", "concert", "conduire", "confier", "congeler", "connoter", "consonne", "contact", "convexe", "copain", "copie", "corail", "corbeau", "cordage", "corniche", "corpus", "correct", "cortège", "cosmique", "costume", "coton", "coude", "coupure", "courage", "couteau", "couvrir", "coyote", "crabe", "crainte", "cravate", "crayon", "créature", "créditer", "crémeux", "creuser", "crevette", "cribler", "crier", "cristal", "critère", "croire", "croquer", "crotale", "crucial", "cruel", "crypter", "cubique", "cueillir", "cuillère", "cuisine", "cuivre", "culminer", "cultiver", "cumuler", "cupide", "curatif", "curseur", "cyanure", "cycle", "cylindre", "cynique", "daigner", "damier", "danger", "danseur", "dauphin", "débattre", "débiter", "déborder", "débrider", "débutant", "décaler", "décembre", "déchirer", "décider", "déclarer", "décorer", "décrire", "décupler", "dédale", "déductif", "déesse", "défensif", "défiler", "défrayer", "dégager", "dégivrer", "déglutir", "dégrafer", "déjeuner", "délice", "déloger", "demander", "demeurer", "démolir", "dénicher", "dénouer", "dentelle", "dénuder", "départ", "dépenser", "déphaser", "déplacer", "déposer", "déranger", "dérober", "désastre", "descente", "désert", "désigner", "désobéir", "dessiner", "destrier", "détacher", "détester", "détourer", "détresse", "devancer", "devenir", "deviner", "devoir", "diable", "dialogue", "diamant", "dicter", "différer", "digérer", "digital", "digne", "diluer", "dimanche", "diminuer", "dioxyde", "directif", "diriger", "discuter", "disposer", "dissiper", "distance", "divertir", "diviser", "docile", "docteur", "dogme", "doigt", "domaine", "domicile", "dompter", "donateur", "donjon", "donner", "dopamine", "dortoir", "dorure", "dosage", "doseur", "dossier", "dotation", "douanier", "double", "douceur", "douter", "doyen", "dragon", "draper", "dresser", "dribbler", "droiture", "duperie", "duplexe", "durable", "durcir", "dynastie", "éblouir", "écarter", "écharpe", "échelle", "éclairer", "éclipse", "éclore", "écluse", "école", "économie", "écorce", "écouter", "écraser", "écrémer", "écrivain", "écrou", "écume", "écureuil", "édifier", "éduquer", "effacer", "effectif", "effigie", "effort", "effrayer", "effusion", "égaliser", "égarer", "éjecter", "élaborer", "élargir", "électron", "élégant", "éléphant", "élève", "éligible", "élitisme", "éloge", "élucider", "éluder", "emballer", "embellir", "embryon", "émeraude", "émission", "emmener", "émotion", "émouvoir", "empereur", "employer", "emporter", "emprise", "émulsion", "encadrer", "enchère", "enclave", "encoche", "endiguer", "endosser", "endroit", "enduire", "énergie", "enfance", "enfermer", "enfouir", "engager", "engin", "englober", "énigme", "enjamber", "enjeu", "enlever", "ennemi", "ennuyeux", "enrichir", "enrobage", "enseigne", "entasser", "entendre", "entier", "entourer", "entraver", "énumérer", "envahir", "enviable", "envoyer", "enzyme", "éolien", "épaissir", "épargne", "épatant", "épaule", "épicerie", "épidémie", "épier", "épilogue", "épine", "épisode", "épitaphe", "époque", "épreuve", "éprouver", "épuisant", "équerre", "équipe", "ériger", "érosion", "erreur", "éruption", "escalier", "espadon", "espèce", "espiègle", "espoir", "esprit", "esquiver", "essayer", "essence", "essieu", "essorer", "estime", "estomac", "estrade", "étagère", "étaler", "étanche", "étatique", "éteindre", "étendoir", "éternel", "éthanol", "éthique", "ethnie", "étirer", "étoffer", "étoile", "étonnant", "étourdir", "étrange", "étroit", "étude", "euphorie", "évaluer", "évasion", "éventail", "évidence", "éviter", "évolutif", "évoquer", "exact", "exagérer", "exaucer", "exceller", "excitant", "exclusif", "excuse", "exécuter", "exemple", "exercer", "exhaler", "exhorter", "exigence", "exiler", "exister", "exotique", "expédier", "explorer", "exposer", "exprimer", "exquis", "extensif", "extraire", "exulter", "fable", "fabuleux", "facette", "facile", "facture", "faiblir", "falaise", "fameux", "famille", "farceur", "farfelu", "farine", "farouche", "fasciner", "fatal", "fatigue", "faucon", "fautif", "faveur", "favori", "fébrile", "féconder", "fédérer", "félin", "femme", "fémur", "fendoir", "féodal", "fermer", "féroce", "ferveur", "festival", "feuille", "feutre", "février", "fiasco", "ficeler", "fictif", "fidèle", "figure", "filature", "filetage", "filière", "filleul", "filmer", "filou", "filtrer", "financer", "finir", "fiole", "firme", "fissure", "fixer", "flairer", "flamme", "flasque", "flatteur", "fléau", "flèche", "fleur", "flexion", "flocon", "flore", "fluctuer", "fluide", "fluvial", "folie", "fonderie", "fongible", "fontaine", "forcer", "forgeron", "formuler", "fortune", "fossile", "foudre", "fougère", "fouiller", "foulure", "fourmi", "fragile", "fraise", "franchir", "frapper", "frayeur", "frégate", "freiner", "frelon", "frémir", "frénésie", "frère", "friable", "friction", "frisson", "frivole", "froid", "fromage", "frontal", "frotter", "fruit", "fugitif", "fuite", "fureur", "furieux", "furtif", "fusion", "futur", "gagner", "galaxie", "galerie", "gambader", "garantir", "gardien", "garnir", "garrigue", "gazelle", "gazon", "géant", "gélatine", "gélule", "gendarme", "général", "génie", "genou", "gentil", "géologie", "géomètre", "géranium", "germe", "gestuel", "geyser", "gibier", "gicler", "girafe", "givre", "glace", "glaive", "glisser", "globe", "gloire", "glorieux", "golfeur", "gomme", "gonfler", "gorge", "gorille", "goudron", "gouffre", "goulot", "goupille", "gourmand", "goutte", "graduel", "graffiti", "graine", "grand", "grappin", "gratuit", "gravir", "grenat", "griffure", "griller", "grimper", "grogner", "gronder", "grotte", "groupe", "gruger", "grutier", "gruyère", "guépard", "guerrier", "guide", "guimauve", "guitare", "gustatif", "gymnaste", "gyrostat", "habitude", "hachoir", "halte", "hameau", "hangar", "hanneton", "haricot", "harmonie", "harpon", "hasard", "hélium", "hématome", "herbe", "hérisson", "hermine", "héron", "hésiter", "heureux", "hiberner", "hibou", "hilarant", "histoire", "hiver", "homard", "hommage", "homogène", "honneur", "honorer", "honteux", "horde", "horizon", "horloge", "hormone", "horrible", "houleux", "housse", "hublot", "huileux", "humain", "humble", "humide", "humour", "hurler", "hydromel", "hygiène", "hymne", "hypnose", "idylle", "ignorer", "iguane", "illicite", "illusion", "image", "imbiber", "imiter", "immense", "immobile", "immuable", "impact", "impérial", "implorer", "imposer", "imprimer", "imputer", "incarner", "incendie", "incident", "incliner", "incolore", "indexer", "indice", "inductif", "inédit", "ineptie", "inexact", "infini", "infliger", "informer", "infusion", "ingérer", "inhaler", "inhiber", "injecter", "injure", "innocent", "inoculer", "inonder", "inscrire", "insecte", "insigne", "insolite", "inspirer", "instinct", "insulter", "intact", "intense", "intime", "intrigue", "intuitif", "inutile", "invasion", "inventer", "inviter", "invoquer", "ironique", "irradier", "irréel", "irriter", "isoler", "ivoire", "ivresse", "jaguar", "jaillir", "jambe", "janvier", "jardin", "jauger", "jaune", "javelot", "jetable", "jeton", "jeudi", "jeunesse", "joindre", "joncher", "jongler", "joueur", "jouissif", "journal", "jovial", "joyau", "joyeux", "jubiler", "jugement", "junior", "jupon", "juriste", "justice", "juteux", "juvénile", "kayak", "kimono", "kiosque", "label", "labial", "labourer", "lacérer", "lactose", "lagune", "laine", "laisser", "laitier", "lambeau", "lamelle", "lampe", "lanceur", "langage", "lanterne", "lapin", "largeur", "larme", "laurier", "lavabo", "lavoir", "lecture", "légal", "léger", "légume", "lessive", "lettre", "levier", "lexique", "lézard", "liasse", "libérer", "libre", "licence", "licorne", "liège", "lièvre", "ligature", "ligoter", "ligue", "limer", "limite", "limonade", "limpide", "linéaire", "lingot", "lionceau", "liquide", "lisière", "lister", "lithium", "litige", "littoral", "livreur", "logique", "lointain", "loisir", "lombric", "loterie", "louer", "lourd", "loutre", "louve", "loyal", "lubie", "lucide", "lucratif", "lueur", "lugubre", "luisant", "lumière", "lunaire", "lundi", "luron", "lutter", "luxueux", "machine", "magasin", "magenta", "magique", "maigre", "maillon", "maintien", "mairie", "maison", "majorer", "malaxer", "maléfice", "malheur", "malice", "mallette", "mammouth", "mandater", "maniable", "manquant", "manteau", "manuel", "marathon", "marbre", "marchand", "mardi", "maritime", "marqueur", "marron", "marteler", "mascotte", "massif", "matériel", "matière", "matraque", "maudire", "maussade", "mauve", "maximal", "méchant", "méconnu", "médaille", "médecin", "méditer", "méduse", "meilleur", "mélange", "mélodie", "membre", "mémoire", "menacer", "mener", "menhir", "mensonge", "mentor", "mercredi", "mérite", "merle", "messager", "mesure", "métal", "météore", "méthode", "métier", "meuble", "miauler", "microbe", "miette", "mignon", "migrer", "milieu", "million", "mimique", "mince", "minéral", "minimal", "minorer", "minute", "miracle", "miroiter", "missile", "mixte", "mobile", "moderne", "moelleux", "mondial", "moniteur", "monnaie", "monotone", "monstre", "montagne", "monument", "moqueur", "morceau", "morsure", "mortier", "moteur", "motif", "mouche", "moufle", "moulin", "mousson", "mouton", "mouvant", "multiple", "munition", "muraille", "murène", "murmure", "muscle", "muséum", "musicien", "mutation", "muter", "mutuel", "myriade", "myrtille", "mystère", "mythique", "nageur", "nappe", "narquois", "narrer", "natation", "nation", "nature", "naufrage", "nautique", "navire", "nébuleux", "nectar", "néfaste", "négation", "négliger", "négocier", "neige", "nerveux", "nettoyer", "neurone", "neutron", "neveu", "niche", "nickel", "nitrate", "niveau", "noble", "nocif", "nocturne", "noirceur", "noisette", "nomade", "nombreux", "nommer", "normatif", "notable", "notifier", "notoire", "nourrir", "nouveau", "novateur", "novembre", "novice", "nuage", "nuancer", "nuire", "nuisible", "numéro", "nuptial", "nuque", "nutritif", "obéir", "objectif", "obliger", "obscur", "observer", "obstacle", "obtenir", "obturer", "occasion", "occuper", "océan", "octobre", "octroyer", "octupler", "oculaire", "odeur", "odorant", "offenser", "officier", "offrir", "ogive", "oiseau", "oisillon", "olfactif", "olivier", "ombrage", "omettre", "onctueux", "onduler", "onéreux", "onirique", "opale", "opaque", "opérer", "opinion", "opportun", "opprimer", "opter", "optique", "orageux", "orange", "orbite", "ordonner", "oreille", "organe", "orgueil", "orifice", "ornement", "orque", "ortie", "osciller", "osmose", "ossature", "otarie", "ouragan", "ourson", "outil", "outrager", "ouvrage", "ovation", "oxyde", "oxygène", "ozone", "paisible", "palace", "palmarès", "palourde", "palper", "panache", "panda", "pangolin", "paniquer", "panneau", "panorama", "pantalon", "papaye", "papier", "papoter", "papyrus", "paradoxe", "parcelle", "paresse", "parfumer", "parler", "parole", "parrain", "parsemer", "partager", "parure", "parvenir", "passion", "pastèque", "paternel", "patience", "patron", "pavillon", "pavoiser", "payer", "paysage", "peigne", "peintre", "pelage", "pélican", "pelle", "pelouse", "peluche", "pendule", "pénétrer", "pénible", "pensif", "pénurie", "pépite", "péplum", "perdrix", "perforer", "période", "permuter", "perplexe", "persil", "perte", "peser", "pétale", "petit", "pétrir", "peuple", "pharaon", "phobie", "phoque", "photon", "phrase", "physique", "piano", "pictural", "pièce", "pierre", "pieuvre", "pilote", "pinceau", "pipette", "piquer", "pirogue", "piscine", "piston", "pivoter", "pixel", "pizza", "placard", "plafond", "plaisir", "planer", "plaque", "plastron", "plateau", "pleurer", "plexus", "pliage", "plomb", "plonger", "pluie", "plumage", "pochette", "poésie", "poète", "pointe", "poirier", "poisson", "poivre", "polaire", "policier", "pollen", "polygone", "pommade", "pompier", "ponctuel", "pondérer", "poney", "portique", "position", "posséder", "posture", "potager", "poteau", "potion", "pouce", "poulain", "poumon", "pourpre", "poussin", "pouvoir", "prairie", "pratique", "précieux", "prédire", "préfixe", "prélude", "prénom", "présence", "prétexte", "prévoir", "primitif", "prince", "prison", "priver", "problème", "procéder", "prodige", "profond", "progrès", "proie", "projeter", "prologue", "promener", "propre", "prospère", "protéger", "prouesse", "proverbe", "prudence", "pruneau", "psychose", "public", "puceron", "puiser", "pulpe", "pulsar", "punaise", "punitif", "pupitre", "purifier", "puzzle", "pyramide", "quasar", "querelle", "question", "quiétude", "quitter", "quotient", "racine", "raconter", "radieux", "ragondin", "raideur", "raisin", "ralentir", "rallonge", "ramasser", "rapide", "rasage", "ratisser", "ravager", "ravin", "rayonner", "réactif", "réagir", "réaliser", "réanimer", "recevoir", "réciter", "réclamer", "récolter", "recruter", "reculer", "recycler", "rédiger", "redouter", "refaire", "réflexe", "réformer", "refrain", "refuge", "régalien", "région", "réglage", "régulier", "réitérer", "rejeter", "rejouer", "relatif", "relever", "relief", "remarque", "remède", "remise", "remonter", "remplir", "remuer", "renard", "renfort", "renifler", "renoncer", "rentrer", "renvoi", "replier", "reporter", "reprise", "reptile", "requin", "réserve", "résineux", "résoudre", "respect", "rester", "résultat", "rétablir", "retenir", "réticule", "retomber", "retracer", "réunion", "réussir", "revanche", "revivre", "révolte", "révulsif", "richesse", "rideau", "rieur", "rigide", "rigoler", "rincer", "riposter", "risible", "risque", "rituel", "rival", "rivière", "rocheux", "romance", "rompre", "ronce", "rondin", "roseau", "rosier", "rotatif", "rotor", "rotule", "rouge", "rouille", "rouleau", "routine", "royaume", "ruban", "rubis", "ruche", "ruelle", "rugueux", "ruiner", "ruisseau", "ruser", "rustique", "rythme", "sabler", "saboter", "sabre", "sacoche", "safari", "sagesse", "saisir", "salade", "salive", "salon", "saluer", "samedi", "sanction", "sanglier", "sarcasme", "sardine", "saturer", "saugrenu", "saumon", "sauter", "sauvage", "savant", "savonner", "scalpel", "scandale", "scélérat", "scénario", "sceptre", "schéma", "science", "scinder", "score", "scrutin", "sculpter", "séance", "sécable", "sécher", "secouer", "sécréter", "sédatif", "séduire", "seigneur", "séjour", "sélectif", "semaine", "sembler", "semence", "séminal", "sénateur", "sensible", "sentence", "séparer", "séquence", "serein", "sergent", "sérieux", "serrure", "sérum", "service", "sésame", "sévir", "sevrage", "sextuple", "sidéral", "siècle", "siéger", "siffler", "sigle", "signal", "silence", "silicium", "simple", "sincère", "sinistre", "siphon", "sirop", "sismique", "situer", "skier", "social", "socle", "sodium", "soigneux", "soldat", "soleil", "solitude", "soluble", "sombre", "sommeil", "somnoler", "sonde", "songeur", "sonnette", "sonore", "sorcier", "sortir", "sosie", "sottise", "soucieux", "soudure", "souffle", "soulever", "soupape", "source", "soutirer", "souvenir", "spacieux", "spatial", "spécial", "sphère", "spiral", "stable", "station", "sternum", "stimulus", "stipuler", "strict", "studieux", "stupeur", "styliste", "sublime", "substrat", "subtil", "subvenir", "succès", "sucre", "suffixe", "suggérer", "suiveur", "sulfate", "superbe", "supplier", "surface", "suricate", "surmener", "surprise", "sursaut", "survie", "suspect", "syllabe", "symbole", "symétrie", "synapse", "syntaxe", "système", "tabac", "tablier", "tactile", "tailler", "talent", "talisman", "talonner", "tambour", "tamiser", "tangible", "tapis", "taquiner", "tarder", "tarif", "tartine", "tasse", "tatami", "tatouage", "taupe", "taureau", "taxer", "témoin", "temporel", "tenaille", "tendre", "teneur", "tenir", "tension", "terminer", "terne", "terrible", "tétine", "texte", "thème", "théorie", "thérapie", "thorax", "tibia", "tiède", "timide", "tirelire", "tiroir", "tissu", "titane", "titre", "tituber", "toboggan", "tolérant", "tomate", "tonique", "tonneau", "toponyme", "torche", "tordre", "tornade", "torpille", "torrent", "torse", "tortue", "totem", "toucher", "tournage", "tousser", "toxine", "traction", "trafic", "tragique", "trahir", "train", "trancher", "travail", "trèfle", "tremper", "trésor", "treuil", "triage", "tribunal", "tricoter", "trilogie", "triomphe", "tripler", "triturer", "trivial", "trombone", "tronc", "tropical", "troupeau", "tuile", "tulipe", "tumulte", "tunnel", "turbine", "tuteur", "tutoyer", "tuyau", "tympan", "typhon", "typique", "tyran", "ubuesque", "ultime", "ultrason", "unanime", "unifier", "union", "unique", "unitaire", "univers", "uranium", "urbain", "urticant", "usage", "usine", "usuel", "usure", "utile", "utopie", "vacarme", "vaccin", "vagabond", "vague", "vaillant", "vaincre", "vaisseau", "valable", "valise", "vallon", "valve", "vampire", "vanille", "vapeur", "varier", "vaseux", "vassal", "vaste", "vecteur", "vedette", "végétal", "véhicule", "veinard", "véloce", "vendredi", "vénérer", "venger", "venimeux", "ventouse", "verdure", "vérin", "vernir", "verrou", "verser", "vertu", "veston", "vétéran", "vétuste", "vexant", "vexer", "viaduc", "viande", "victoire", "vidange", "vidéo", "vignette", "vigueur", "vilain", "village", "vinaigre", "violon", "vipère", "virement", "virtuose", "virus", "visage", "viseur", "vision", "visqueux", "visuel", "vital", "vitesse", "viticole", "vitrine", "vivace", "vivipare", "vocation", "voguer", "voile", "voisin", "voiture", "volaille", "volcan", "voltiger", "volume", "vorace", "vortex", "voter", "vouloir", "voyage", "voyelle", "wagon", "xénon", "yacht", "zèbre", "zénith", "zeste", "zoologie" };
 
+        /// <summary>
+        /// French Constructor
+        /// </summary>
         public French() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Japanese Words
+    /// </summary>
     public class Japanese : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "あいこくしん", "あいさつ", "あいだ", "あおぞら", "あかちゃん", "あきる", "あけがた", "あける", "あこがれる", "あさい", "あさひ", "あしあと", "あじわう", "あずかる", "あずき", "あそぶ", "あたえる", "あたためる", "あたりまえ", "あたる", "あつい", "あつかう", "あっしゅく", "あつまり", "あつめる", "あてな", "あてはまる", "あひる", "あぶら", "あぶる", "あふれる", "あまい", "あまど", "あまやかす", "あまり", "あみもの", "あめりか", "あやまる", "あゆむ", "あらいぐま", "あらし", "あらすじ", "あらためる", "あらゆる", "あらわす", "ありがとう", "あわせる", "あわてる", "あんい", "あんがい", "あんこ", "あんぜん", "あんてい", "あんない", "あんまり", "いいだす", "いおん", "いがい", "いがく", "いきおい", "いきなり", "いきもの", "いきる", "いくじ", "いくぶん", "いけばな", "いけん", "いこう", "いこく", "いこつ", "いさましい", "いさん", "いしき", "いじゅう", "いじょう", "いじわる", "いずみ", "いずれ", "いせい", "いせえび", "いせかい", "いせき", "いぜん", "いそうろう", "いそがしい", "いだい", "いだく", "いたずら", "いたみ", "いたりあ", "いちおう", "いちじ", "いちど", "いちば", "いちぶ", "いちりゅう", "いつか", "いっしゅん", "いっせい", "いっそう", "いったん", "いっち", "いってい", "いっぽう", "いてざ", "いてん", "いどう", "いとこ", "いない", "いなか", "いねむり", "いのち", "いのる", "いはつ", "いばる", "いはん", "いびき", "いひん", "いふく", "いへん", "いほう", "いみん", "いもうと", "いもたれ", "いもり", "いやがる", "いやす", "いよかん", "いよく", "いらい", "いらすと", "いりぐち", "いりょう", "いれい", "いれもの", "いれる", "いろえんぴつ", "いわい", "いわう", "いわかん", "いわば", "いわゆる", "いんげんまめ", "いんさつ", "いんしょう", "いんよう", "うえき", "うえる", "うおざ", "うがい", "うかぶ", "うかべる", "うきわ", "うくらいな", "うくれれ", "うけたまわる", "うけつけ", "うけとる", "うけもつ", "うける", "うごかす", "うごく", "うこん", "うさぎ", "うしなう", "うしろがみ", "うすい", "うすぎ", "うすぐらい", "うすめる", "うせつ", "うちあわせ", "うちがわ", "うちき", "うちゅう", "うっかり", "うつくしい", "うったえる", "うつる", "うどん", "うなぎ", "うなじ", "うなずく", "うなる", "うねる", "うのう", "うぶげ", "うぶごえ", "うまれる", "うめる", "うもう", "うやまう", "うよく", "うらがえす", "うらぐち", "うらない", "うりあげ", "うりきれ", "うるさい", "うれしい", "うれゆき", "うれる", "うろこ", "うわき", "うわさ", "うんこう", "うんちん", "うんてん", "うんどう", "えいえん", "えいが", "えいきょう", "えいご", "えいせい", "えいぶん", "えいよう", "えいわ", "えおり", "えがお", "えがく", "えきたい", "えくせる", "えしゃく", "えすて", "えつらん", "えのぐ", "えほうまき", "えほん", "えまき", "えもじ", "えもの", "えらい", "えらぶ", "えりあ", "えんえん", "えんかい", "えんぎ", "えんげき", "えんしゅう", "えんぜつ", "えんそく", "えんちょう", "えんとつ", "おいかける", "おいこす", "おいしい", "おいつく", "おうえん", "おうさま", "おうじ", "おうせつ", "おうたい", "おうふく", "おうべい", "おうよう", "おえる", "おおい", "おおう", "おおどおり", "おおや", "おおよそ", "おかえり", "おかず", "おがむ", "おかわり", "おぎなう", "おきる", "おくさま", "おくじょう", "おくりがな", "おくる", "おくれる", "おこす", "おこなう", "おこる", "おさえる", "おさない", "おさめる", "おしいれ", "おしえる", "おじぎ", "おじさん", "おしゃれ", "おそらく", "おそわる", "おたがい", "おたく", "おだやか", "おちつく", "おっと", "おつり", "おでかけ", "おとしもの", "おとなしい", "おどり", "おどろかす", "おばさん", "おまいり", "おめでとう", "おもいで", "おもう", "おもたい", "おもちゃ", "おやつ", "おやゆび", "およぼす", "おらんだ", "おろす", "おんがく", "おんけい", "おんしゃ", "おんせん", "おんだん", "おんちゅう", "おんどけい", "かあつ", "かいが", "がいき", "がいけん", "がいこう", "かいさつ", "かいしゃ", "かいすいよく", "かいぜん", "かいぞうど", "かいつう", "かいてん", "かいとう", "かいふく", "がいへき", "かいほう", "かいよう", "がいらい", "かいわ", "かえる", "かおり", "かかえる", "かがく", "かがし", "かがみ", "かくご", "かくとく", "かざる", "がぞう", "かたい", "かたち", "がちょう", "がっきゅう", "がっこう", "がっさん", "がっしょう", "かなざわし", "かのう", "がはく", "かぶか", "かほう", "かほご", "かまう", "かまぼこ", "かめれおん", "かゆい", "かようび", "からい", "かるい", "かろう", "かわく", "かわら", "がんか", "かんけい", "かんこう", "かんしゃ", "かんそう", "かんたん", "かんち", "がんばる", "きあい", "きあつ", "きいろ", "ぎいん", "きうい", "きうん", "きえる", "きおう", "きおく", "きおち", "きおん", "きかい", "きかく", "きかんしゃ", "ききて", "きくばり", "きくらげ", "きけんせい", "きこう", "きこえる", "きこく", "きさい", "きさく", "きさま", "きさらぎ", "ぎじかがく", "ぎしき", "ぎじたいけん", "ぎじにってい", "ぎじゅつしゃ", "きすう", "きせい", "きせき", "きせつ", "きそう", "きぞく", "きぞん", "きたえる", "きちょう", "きつえん", "ぎっちり", "きつつき", "きつね", "きてい", "きどう", "きどく", "きない", "きなが", "きなこ", "きぬごし", "きねん", "きのう", "きのした", "きはく", "きびしい", "きひん", "きふく", "きぶん", "きぼう", "きほん", "きまる", "きみつ", "きむずかしい", "きめる", "きもだめし", "きもち", "きもの", "きゃく", "きやく", "ぎゅうにく", "きよう", "きょうりゅう", "きらい", "きらく", "きりん", "きれい", "きれつ", "きろく", "ぎろん", "きわめる", "ぎんいろ", "きんかくじ", "きんじょ", "きんようび", "ぐあい", "くいず", "くうかん", "くうき", "くうぐん", "くうこう", "ぐうせい", "くうそう", "ぐうたら", "くうふく", "くうぼ", "くかん", "くきょう", "くげん", "ぐこう", "くさい", "くさき", "くさばな", "くさる", "くしゃみ", "くしょう", "くすのき", "くすりゆび", "くせげ", "くせん", "ぐたいてき", "くださる", "くたびれる", "くちこみ", "くちさき", "くつした", "ぐっすり", "くつろぐ", "くとうてん", "くどく", "くなん", "くねくね", "くのう", "くふう", "くみあわせ", "くみたてる", "くめる", "くやくしょ", "くらす", "くらべる", "くるま", "くれる", "くろう", "くわしい", "ぐんかん", "ぐんしょく", "ぐんたい", "ぐんて", "けあな", "けいかく", "けいけん", "けいこ", "けいさつ", "げいじゅつ", "けいたい", "げいのうじん", "けいれき", "けいろ", "けおとす", "けおりもの", "げきか", "げきげん", "げきだん", "げきちん", "げきとつ", "げきは", "げきやく", "げこう", "げこくじょう", "げざい", "けさき", "げざん", "けしき", "けしごむ", "けしょう", "げすと", "けたば", "けちゃっぷ", "けちらす", "けつあつ", "けつい", "けつえき", "けっこん", "けつじょ", "けっせき", "けってい", "けつまつ", "げつようび", "げつれい", "けつろん", "げどく", "けとばす", "けとる", "けなげ", "けなす", "けなみ", "けぬき", "げねつ", "けねん", "けはい", "げひん", "けぶかい", "げぼく", "けまり", "けみかる", "けむし", "けむり", "けもの", "けらい", "けろけろ", "けわしい", "けんい", "けんえつ", "けんお", "けんか", "げんき", "けんげん", "けんこう", "けんさく", "けんしゅう", "けんすう", "げんそう", "けんちく", "けんてい", "けんとう", "けんない", "けんにん", "げんぶつ", "けんま", "けんみん", "けんめい", "けんらん", "けんり", "こあくま", "こいぬ", "こいびと", "ごうい", "こうえん", "こうおん", "こうかん", "ごうきゅう", "ごうけい", "こうこう", "こうさい", "こうじ", "こうすい", "ごうせい", "こうそく", "こうたい", "こうちゃ", "こうつう", "こうてい", "こうどう", "こうない", "こうはい", "ごうほう", "ごうまん", "こうもく", "こうりつ", "こえる", "こおり", "ごかい", "ごがつ", "ごかん", "こくご", "こくさい", "こくとう", "こくない", "こくはく", "こぐま", "こけい", "こける", "ここのか", "こころ", "こさめ", "こしつ", "こすう", "こせい", "こせき", "こぜん", "こそだて", "こたい", "こたえる", "こたつ", "こちょう", "こっか", "こつこつ", "こつばん", "こつぶ", "こてい", "こてん", "ことがら", "ことし", "ことば", "ことり", "こなごな", "こねこね", "このまま", "このみ", "このよ", "ごはん", "こひつじ", "こふう", "こふん", "こぼれる", "ごまあぶら", "こまかい", "ごますり", "こまつな", "こまる", "こむぎこ", "こもじ", "こもち", "こもの", "こもん", "こやく", "こやま", "こゆう", "こゆび", "こよい", "こよう", "こりる", "これくしょん", "ころっけ", "こわもて", "こわれる", "こんいん", "こんかい", "こんき", "こんしゅう", "こんすい", "こんだて", "こんとん", "こんなん", "こんびに", "こんぽん", "こんまけ", "こんや", "こんれい", "こんわく", "ざいえき", "さいかい", "さいきん", "ざいげん", "ざいこ", "さいしょ", "さいせい", "ざいたく", "ざいちゅう", "さいてき", "ざいりょう", "さうな", "さかいし", "さがす", "さかな", "さかみち", "さがる", "さぎょう", "さくし", "さくひん", "さくら", "さこく", "さこつ", "さずかる", "ざせき", "さたん", "さつえい", "ざつおん", "ざっか", "ざつがく", "さっきょく", "ざっし", "さつじん", "ざっそう", "さつたば", "さつまいも", "さてい", "さといも", "さとう", "さとおや", "さとし", "さとる", "さのう", "さばく", "さびしい", "さべつ", "さほう", "さほど", "さます", "さみしい", "さみだれ", "さむけ", "さめる", "さやえんどう", "さゆう", "さよう", "さよく", "さらだ", "ざるそば", "さわやか", "さわる", "さんいん", "さんか", "さんきゃく", "さんこう", "さんさい", "ざんしょ", "さんすう", "さんせい", "さんそ", "さんち", "さんま", "さんみ", "さんらん", "しあい", "しあげ", "しあさって", "しあわせ", "しいく", "しいん", "しうち", "しえい", "しおけ", "しかい", "しかく", "じかん", "しごと", "しすう", "じだい", "したうけ", "したぎ", "したて", "したみ", "しちょう", "しちりん", "しっかり", "しつじ", "しつもん", "してい", "してき", "してつ", "じてん", "じどう", "しなぎれ", "しなもの", "しなん", "しねま", "しねん", "しのぐ", "しのぶ", "しはい", "しばかり", "しはつ", "しはらい", "しはん", "しひょう", "しふく", "じぶん", "しへい", "しほう", "しほん", "しまう", "しまる", "しみん", "しむける", "じむしょ", "しめい", "しめる", "しもん", "しゃいん", "しゃうん", "しゃおん", "じゃがいも", "しやくしょ", "しゃくほう", "しゃけん", "しゃこ", "しゃざい", "しゃしん", "しゃせん", "しゃそう", "しゃたい", "しゃちょう", "しゃっきん", "じゃま", "しゃりん", "しゃれい", "じゆう", "じゅうしょ", "しゅくはく", "じゅしん", "しゅっせき", "しゅみ", "しゅらば", "じゅんばん", "しょうかい", "しょくたく", "しょっけん", "しょどう", "しょもつ", "しらせる", "しらべる", "しんか", "しんこう", "じんじゃ", "しんせいじ", "しんちく", "しんりん", "すあげ", "すあし", "すあな", "ずあん", "すいえい", "すいか", "すいとう", "ずいぶん", "すいようび", "すうがく", "すうじつ", "すうせん", "すおどり", "すきま", "すくう", "すくない", "すける", "すごい", "すこし", "ずさん", "すずしい", "すすむ", "すすめる", "すっかり", "ずっしり", "ずっと", "すてき", "すてる", "すねる", "すのこ", "すはだ", "すばらしい", "ずひょう", "ずぶぬれ", "すぶり", "すふれ", "すべて", "すべる", "ずほう", "すぼん", "すまい", "すめし", "すもう", "すやき", "すらすら", "するめ", "すれちがう", "すろっと", "すわる", "すんぜん", "すんぽう", "せあぶら", "せいかつ", "せいげん", "せいじ", "せいよう", "せおう", "せかいかん", "せきにん", "せきむ", "せきゆ", "せきらんうん", "せけん", "せこう", "せすじ", "せたい", "せたけ", "せっかく", "せっきゃく", "ぜっく", "せっけん", "せっこつ", "せっさたくま", "せつぞく", "せつだん", "せつでん", "せっぱん", "せつび", "せつぶん", "せつめい", "せつりつ", "せなか", "せのび", "せはば", "せびろ", "せぼね", "せまい", "せまる", "せめる", "せもたれ", "せりふ", "ぜんあく", "せんい", "せんえい", "せんか", "せんきょ", "せんく", "せんげん", "ぜんご", "せんさい", "せんしゅ", "せんすい", "せんせい", "せんぞ", "せんたく", "せんちょう", "せんてい", "せんとう", "せんぬき", "せんねん", "せんぱい", "ぜんぶ", "ぜんぽう", "せんむ", "せんめんじょ", "せんもん", "せんやく", "せんゆう", "せんよう", "ぜんら", "ぜんりゃく", "せんれい", "せんろ", "そあく", "そいとげる", "そいね", "そうがんきょう", "そうき", "そうご", "そうしん", "そうだん", "そうなん", "そうび", "そうめん", "そうり", "そえもの", "そえん", "そがい", "そげき", "そこう", "そこそこ", "そざい", "そしな", "そせい", "そせん", "そそぐ", "そだてる", "そつう", "そつえん", "そっかん", "そつぎょう", "そっけつ", "そっこう", "そっせん", "そっと", "そとがわ", "そとづら", "そなえる", "そなた", "そふぼ", "そぼく", "そぼろ", "そまつ", "そまる", "そむく", "そむりえ", "そめる", "そもそも", "そよかぜ", "そらまめ", "そろう", "そんかい", "そんけい", "そんざい", "そんしつ", "そんぞく", "そんちょう", "ぞんび", "ぞんぶん", "そんみん", "たあい", "たいいん", "たいうん", "たいえき", "たいおう", "だいがく", "たいき", "たいぐう", "たいけん", "たいこ", "たいざい", "だいじょうぶ", "だいすき", "たいせつ", "たいそう", "だいたい", "たいちょう", "たいてい", "だいどころ", "たいない", "たいねつ", "たいのう", "たいはん", "だいひょう", "たいふう", "たいへん", "たいほ", "たいまつばな", "たいみんぐ", "たいむ", "たいめん", "たいやき", "たいよう", "たいら", "たいりょく", "たいる", "たいわん", "たうえ", "たえる", "たおす", "たおる", "たおれる", "たかい", "たかね", "たきび", "たくさん", "たこく", "たこやき", "たさい", "たしざん", "だじゃれ", "たすける", "たずさわる", "たそがれ", "たたかう", "たたく", "ただしい", "たたみ", "たちばな", "だっかい", "だっきゃく", "だっこ", "だっしゅつ", "だったい", "たてる", "たとえる", "たなばた", "たにん", "たぬき", "たのしみ", "たはつ", "たぶん", "たべる", "たぼう", "たまご", "たまる", "だむる", "ためいき", "ためす", "ためる", "たもつ", "たやすい", "たよる", "たらす", "たりきほんがん", "たりょう", "たりる", "たると", "たれる", "たれんと", "たろっと", "たわむれる", "だんあつ", "たんい", "たんおん", "たんか", "たんき", "たんけん", "たんご", "たんさん", "たんじょうび", "だんせい", "たんそく", "たんたい", "だんち", "たんてい", "たんとう", "だんな", "たんにん", "だんねつ", "たんのう", "たんぴん", "だんぼう", "たんまつ", "たんめい", "だんれつ", "だんろ", "だんわ", "ちあい", "ちあん", "ちいき", "ちいさい", "ちえん", "ちかい", "ちから", "ちきゅう", "ちきん", "ちけいず", "ちけん", "ちこく", "ちさい", "ちしき", "ちしりょう", "ちせい", "ちそう", "ちたい", "ちたん", "ちちおや", "ちつじょ", "ちてき", "ちてん", "ちぬき", "ちぬり", "ちのう", "ちひょう", "ちへいせん", "ちほう", "ちまた", "ちみつ", "ちみどろ", "ちめいど", "ちゃんこなべ", "ちゅうい", "ちゆりょく", "ちょうし", "ちょさくけん", "ちらし", "ちらみ", "ちりがみ", "ちりょう", "ちるど", "ちわわ", "ちんたい", "ちんもく", "ついか", "ついたち", "つうか", "つうじょう", "つうはん", "つうわ", "つかう", "つかれる", "つくね", "つくる", "つけね", "つける", "つごう", "つたえる", "つづく", "つつじ", "つつむ", "つとめる", "つながる", "つなみ", "つねづね", "つのる", "つぶす", "つまらない", "つまる", "つみき", "つめたい", "つもり", "つもる", "つよい", "つるぼ", "つるみく", "つわもの", "つわり", "てあし", "てあて", "てあみ", "ていおん", "ていか", "ていき", "ていけい", "ていこく", "ていさつ", "ていし", "ていせい", "ていたい", "ていど", "ていねい", "ていひょう", "ていへん", "ていぼう", "てうち", "ておくれ", "てきとう", "てくび", "でこぼこ", "てさぎょう", "てさげ", "てすり", "てそう", "てちがい", "てちょう", "てつがく", "てつづき", "でっぱ", "てつぼう", "てつや", "でぬかえ", "てぬき", "てぬぐい", "てのひら", "てはい", "てぶくろ", "てふだ", "てほどき", "てほん", "てまえ", "てまきずし", "てみじか", "てみやげ", "てらす", "てれび", "てわけ", "てわたし", "でんあつ", "てんいん", "てんかい", "てんき", "てんぐ", "てんけん", "てんごく", "てんさい", "てんし", "てんすう", "でんち", "てんてき", "てんとう", "てんない", "てんぷら", "てんぼうだい", "てんめつ", "てんらんかい", "でんりょく", "でんわ", "どあい", "といれ", "どうかん", "とうきゅう", "どうぐ", "とうし", "とうむぎ", "とおい", "とおか", "とおく", "とおす", "とおる", "とかい", "とかす", "ときおり", "ときどき", "とくい", "とくしゅう", "とくてん", "とくに", "とくべつ", "とけい", "とける", "とこや", "とさか", "としょかん", "とそう", "とたん", "とちゅう", "とっきゅう", "とっくん", "とつぜん", "とつにゅう", "とどける", "ととのえる", "とない", "となえる", "となり", "とのさま", "とばす", "どぶがわ", "とほう", "とまる", "とめる", "ともだち", "ともる", "どようび", "とらえる", "とんかつ", "どんぶり", "ないかく", "ないこう", "ないしょ", "ないす", "ないせん", "ないそう", "なおす", "ながい", "なくす", "なげる", "なこうど", "なさけ", "なたでここ", "なっとう", "なつやすみ", "ななおし", "なにごと", "なにもの", "なにわ", "なのか", "なふだ", "なまいき", "なまえ", "なまみ", "なみだ", "なめらか", "なめる", "なやむ", "ならう", "ならび", "ならぶ", "なれる", "なわとび", "なわばり", "にあう", "にいがた", "にうけ", "におい", "にかい", "にがて", "にきび", "にくしみ", "にくまん", "にげる", "にさんかたんそ", "にしき", "にせもの", "にちじょう", "にちようび", "にっか", "にっき", "にっけい", "にっこう", "にっさん", "にっしょく", "にっすう", "にっせき", "にってい", "になう", "にほん", "にまめ", "にもつ", "にやり", "にゅういん", "にりんしゃ", "にわとり", "にんい", "にんか", "にんき", "にんげん", "にんしき", "にんずう", "にんそう", "にんたい", "にんち", "にんてい", "にんにく", "にんぷ", "にんまり", "にんむ", "にんめい", "にんよう", "ぬいくぎ", "ぬかす", "ぬぐいとる", "ぬぐう", "ぬくもり", "ぬすむ", "ぬまえび", "ぬめり", "ぬらす", "ぬんちゃく", "ねあげ", "ねいき", "ねいる", "ねいろ", "ねぐせ", "ねくたい", "ねくら", "ねこぜ", "ねこむ", "ねさげ", "ねすごす", "ねそべる", "ねだん", "ねつい", "ねっしん", "ねつぞう", "ねったいぎょ", "ねぶそく", "ねふだ", "ねぼう", "ねほりはほり", "ねまき", "ねまわし", "ねみみ", "ねむい", "ねむたい", "ねもと", "ねらう", "ねわざ", "ねんいり", "ねんおし", "ねんかん", "ねんきん", "ねんぐ", "ねんざ", "ねんし", "ねんちゃく", "ねんど", "ねんぴ", "ねんぶつ", "ねんまつ", "ねんりょう", "ねんれい", "のいず", "のおづま", "のがす", "のきなみ", "のこぎり", "のこす", "のこる", "のせる", "のぞく", "のぞむ", "のたまう", "のちほど", "のっく", "のばす", "のはら", "のべる", "のぼる", "のみもの", "のやま", "のらいぬ", "のらねこ", "のりもの", "のりゆき", "のれん", "のんき", "ばあい", "はあく", "ばあさん", "ばいか", "ばいく", "はいけん", "はいご", "はいしん", "はいすい", "はいせん", "はいそう", "はいち", "ばいばい", "はいれつ", "はえる", "はおる", "はかい", "ばかり", "はかる", "はくしゅ", "はけん", "はこぶ", "はさみ", "はさん", "はしご", "ばしょ", "はしる", "はせる", "ぱそこん", "はそん", "はたん", "はちみつ", "はつおん", "はっかく", "はづき", "はっきり", "はっくつ", "はっけん", "はっこう", "はっさん", "はっしん", "はったつ", "はっちゅう", "はってん", "はっぴょう", "はっぽう", "はなす", "はなび", "はにかむ", "はぶらし", "はみがき", "はむかう", "はめつ", "はやい", "はやし", "はらう", "はろうぃん", "はわい", "はんい", "はんえい", "はんおん", "はんかく", "はんきょう", "ばんぐみ", "はんこ", "はんしゃ", "はんすう", "はんだん", "ぱんち", "ぱんつ", "はんてい", "はんとし", "はんのう", "はんぱ", "はんぶん", "はんぺん", "はんぼうき", "はんめい", "はんらん", "はんろん", "ひいき", "ひうん", "ひえる", "ひかく", "ひかり", "ひかる", "ひかん", "ひくい", "ひけつ", "ひこうき", "ひこく", "ひさい", "ひさしぶり", "ひさん", "びじゅつかん", "ひしょ", "ひそか", "ひそむ", "ひたむき", "ひだり", "ひたる", "ひつぎ", "ひっこし", "ひっし", "ひつじゅひん", "ひっす", "ひつぜん", "ぴったり", "ぴっちり", "ひつよう", "ひてい", "ひとごみ", "ひなまつり", "ひなん", "ひねる", "ひはん", "ひびく", "ひひょう", "ひほう", "ひまわり", "ひまん", "ひみつ", "ひめい", "ひめじし", "ひやけ", "ひやす", "ひよう", "びょうき", "ひらがな", "ひらく", "ひりつ", "ひりょう", "ひるま", "ひるやすみ", "ひれい", "ひろい", "ひろう", "ひろき", "ひろゆき", "ひんかく", "ひんけつ", "ひんこん", "ひんしゅ", "ひんそう", "ぴんち", "ひんぱん", "びんぼう", "ふあん", "ふいうち", "ふうけい", "ふうせん", "ぷうたろう", "ふうとう", "ふうふ", "ふえる", "ふおん", "ふかい", "ふきん", "ふくざつ", "ふくぶくろ", "ふこう", "ふさい", "ふしぎ", "ふじみ", "ふすま", "ふせい", "ふせぐ", "ふそく", "ぶたにく", "ふたん", "ふちょう", "ふつう", "ふつか", "ふっかつ", "ふっき", "ふっこく", "ぶどう", "ふとる", "ふとん", "ふのう", "ふはい", "ふひょう", "ふへん", "ふまん", "ふみん", "ふめつ", "ふめん", "ふよう", "ふりこ", "ふりる", "ふるい", "ふんいき", "ぶんがく", "ぶんぐ", "ふんしつ", "ぶんせき", "ふんそう", "ぶんぽう", "へいあん", "へいおん", "へいがい", "へいき", "へいげん", "へいこう", "へいさ", "へいしゃ", "へいせつ", "へいそ", "へいたく", "へいてん", "へいねつ", "へいわ", "へきが", "へこむ", "べにいろ", "べにしょうが", "へらす", "へんかん", "べんきょう", "べんごし", "へんさい", "へんたい", "べんり", "ほあん", "ほいく", "ぼうぎょ", "ほうこく", "ほうそう", "ほうほう", "ほうもん", "ほうりつ", "ほえる", "ほおん", "ほかん", "ほきょう", "ぼきん", "ほくろ", "ほけつ", "ほけん", "ほこう", "ほこる", "ほしい", "ほしつ", "ほしゅ", "ほしょう", "ほせい", "ほそい", "ほそく", "ほたて", "ほたる", "ぽちぶくろ", "ほっきょく", "ほっさ", "ほったん", "ほとんど", "ほめる", "ほんい", "ほんき", "ほんけ", "ほんしつ", "ほんやく", "まいにち", "まかい", "まかせる", "まがる", "まける", "まこと", "まさつ", "まじめ", "ますく", "まぜる", "まつり", "まとめ", "まなぶ", "まぬけ", "まねく", "まほう", "まもる", "まゆげ", "まよう", "まろやか", "まわす", "まわり", "まわる", "まんが", "まんきつ", "まんぞく", "まんなか", "みいら", "みうち", "みえる", "みがく", "みかた", "みかん", "みけん", "みこん", "みじかい", "みすい", "みすえる", "みせる", "みっか", "みつかる", "みつける", "みてい", "みとめる", "みなと", "みなみかさい", "みねらる", "みのう", "みのがす", "みほん", "みもと", "みやげ", "みらい", "みりょく", "みわく", "みんか", "みんぞく", "むいか", "むえき", "むえん", "むかい", "むかう", "むかえ", "むかし", "むぎちゃ", "むける", "むげん", "むさぼる", "むしあつい", "むしば", "むじゅん", "むしろ", "むすう", "むすこ", "むすぶ", "むすめ", "むせる", "むせん", "むちゅう", "むなしい", "むのう", "むやみ", "むよう", "むらさき", "むりょう", "むろん", "めいあん", "めいうん", "めいえん", "めいかく", "めいきょく", "めいさい", "めいし", "めいそう", "めいぶつ", "めいれい", "めいわく", "めぐまれる", "めざす", "めした", "めずらしい", "めだつ", "めまい", "めやす", "めんきょ", "めんせき", "めんどう", "もうしあげる", "もうどうけん", "もえる", "もくし", "もくてき", "もくようび", "もちろん", "もどる", "もらう", "もんく", "もんだい", "やおや", "やける", "やさい", "やさしい", "やすい", "やすたろう", "やすみ", "やせる", "やそう", "やたい", "やちん", "やっと", "やっぱり", "やぶる", "やめる", "ややこしい", "やよい", "やわらかい", "ゆうき", "ゆうびんきょく", "ゆうべ", "ゆうめい", "ゆけつ", "ゆしゅつ", "ゆせん", "ゆそう", "ゆたか", "ゆちゃく", "ゆでる", "ゆにゅう", "ゆびわ", "ゆらい", "ゆれる", "ようい", "ようか", "ようきゅう", "ようじ", "ようす", "ようちえん", "よかぜ", "よかん", "よきん", "よくせい", "よくぼう", "よけい", "よごれる", "よさん", "よしゅう", "よそう", "よそく", "よっか", "よてい", "よどがわく", "よねつ", "よやく", "よゆう", "よろこぶ", "よろしい", "らいう", "らくがき", "らくご", "らくさつ", "らくだ", "らしんばん", "らせん", "らぞく", "らたい", "らっか", "られつ", "りえき", "りかい", "りきさく", "りきせつ", "りくぐん", "りくつ", "りけん", "りこう", "りせい", "りそう", "りそく", "りてん", "りねん", "りゆう", "りゅうがく", "りよう", "りょうり", "りょかん", "りょくちゃ", "りょこう", "りりく", "りれき", "りろん", "りんご", "るいけい", "るいさい", "るいじ", "るいせき", "るすばん", "るりがわら", "れいかん", "れいぎ", "れいせい", "れいぞうこ", "れいとう", "れいぼう", "れきし", "れきだい", "れんあい", "れんけい", "れんこん", "れんさい", "れんしゅう", "れんぞく", "れんらく", "ろうか", "ろうご", "ろうじん", "ろうそく", "ろくが", "ろこつ", "ろじうら", "ろしゅつ", "ろせん", "ろてん", "ろめん", "ろれつ", "ろんぎ", "ろんぱ", "ろんぶん", "ろんり", "わかす", "わかめ", "わかやま", "わかれる", "わしつ", "わじまし", "わすれもの", "わらう", "われる" };
 
+        /// <summary>
+        /// Japanese Constructor
+        /// </summary>
         public Japanese() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Spanish Words
+    /// </summary>
     public class Spanish : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "ábaco", "abdomen", "abeja", "abierto", "abogado", "abono", "aborto", "abrazo", "abrir", "abuelo", "abuso", "acabar", "academia", "acceso", "acción", "aceite", "acelga", "acento", "aceptar", "ácido", "aclarar", "acné", "acoger", "acoso", "activo", "acto", "actriz", "actuar", "acudir", "acuerdo", "acusar", "adicto", "admitir", "adoptar", "adorno", "aduana", "adulto", "aéreo", "afectar", "afición", "afinar", "afirmar", "ágil", "agitar", "agonía", "agosto", "agotar", "agregar", "agrio", "agua", "agudo", "águila", "aguja", "ahogo", "ahorro", "aire", "aislar", "ajedrez", "ajeno", "ajuste", "alacrán", "alambre", "alarma", "alba", "álbum", "alcalde", "aldea", "alegre", "alejar", "alerta", "aleta", "alfiler", "alga", "algodón", "aliado", "aliento", "alivio", "alma", "almeja", "almíbar", "altar", "alteza", "altivo", "alto", "altura", "alumno", "alzar", "amable", "amante", "amapola", "amargo", "amasar", "ámbar", "ámbito", "ameno", "amigo", "amistad", "amor", "amparo", "amplio", "ancho", "anciano", "ancla", "andar", "andén", "anemia", "ángulo", "anillo", "ánimo", "anís", "anotar", "antena", "antiguo", "antojo", "anual", "anular", "anuncio", "añadir", "añejo", "año", "apagar", "aparato", "apetito", "apio", "aplicar", "apodo", "aporte", "apoyo", "aprender", "aprobar", "apuesta", "apuro", "arado", "araña", "arar", "árbitro", "árbol", "arbusto", "archivo", "arco", "arder", "ardilla", "arduo", "área", "árido", "aries", "armonía", "arnés", "aroma", "arpa", "arpón", "arreglo", "arroz", "arruga", "arte", "artista", "asa", "asado", "asalto", "ascenso", "asegurar", "aseo", "asesor", "asiento", "asilo", "asistir", "asno", "asombro", "áspero", "astilla", "astro", "astuto", "asumir", "asunto", "atajo", "ataque", "atar", "atento", "ateo", "ático", "atleta", "átomo", "atraer", "atroz", "atún", "audaz", "audio", "auge", "aula", "aumento", "ausente", "autor", "aval", "avance", "avaro", "ave", "avellana", "avena", "avestruz", "avión", "aviso", "ayer", "ayuda", "ayuno", "azafrán", "azar", "azote", "azúcar", "azufre", "azul", "baba", "babor", "bache", "bahía", "baile", "bajar", "balanza", "balcón", "balde", "bambú", "banco", "banda", "baño", "barba", "barco", "barniz", "barro", "báscula", "bastón", "basura", "batalla", "batería", "batir", "batuta", "baúl", "bazar", "bebé", "bebida", "bello", "besar", "beso", "bestia", "bicho", "bien", "bingo", "blanco", "bloque", "blusa", "boa", "bobina", "bobo", "boca", "bocina", "boda", "bodega", "boina", "bola", "bolero", "bolsa", "bomba", "bondad", "bonito", "bono", "bonsái", "borde", "borrar", "bosque", "bote", "botín", "bóveda", "bozal", "bravo", "brazo", "brecha", "breve", "brillo", "brinco", "brisa", "broca", "broma", "bronce", "brote", "bruja", "brusco", "bruto", "buceo", "bucle", "bueno", "buey", "bufanda", "bufón", "búho", "buitre", "bulto", "burbuja", "burla", "burro", "buscar", "butaca", "buzón", "caballo", "cabeza", "cabina", "cabra", "cacao", "cadáver", "cadena", "caer", "café", "caída", "caimán", "caja", "cajón", "cal", "calamar", "calcio", "caldo", "calidad", "calle", "calma", "calor", "calvo", "cama", "cambio", "camello", "camino", "campo", "cáncer", "candil", "canela", "canguro", "canica", "canto", "caña", "cañón", "caoba", "caos", "capaz", "capitán", "capote", "captar", "capucha", "cara", "carbón", "cárcel", "careta", "carga", "cariño", "carne", "carpeta", "carro", "carta", "casa", "casco", "casero", "caspa", "castor", "catorce", "catre", "caudal", "causa", "cazo", "cebolla", "ceder", "cedro", "celda", "célebre", "celoso", "célula", "cemento", "ceniza", "centro", "cerca", "cerdo", "cereza", "cero", "cerrar", "certeza", "césped", "cetro", "chacal", "chaleco", "champú", "chancla", "chapa", "charla", "chico", "chiste", "chivo", "choque", "choza", "chuleta", "chupar", "ciclón", "ciego", "cielo", "cien", "cierto", "cifra", "cigarro", "cima", "cinco", "cine", "cinta", "ciprés", "circo", "ciruela", "cisne", "cita", "ciudad", "clamor", "clan", "claro", "clase", "clave", "cliente", "clima", "clínica", "cobre", "cocción", "cochino", "cocina", "coco", "código", "codo", "cofre", "coger", "cohete", "cojín", "cojo", "cola", "colcha", "colegio", "colgar", "colina", "collar", "colmo", "columna", "combate", "comer", "comida", "cómodo", "compra", "conde", "conejo", "conga", "conocer", "consejo", "contar", "copa", "copia", "corazón", "corbata", "corcho", "cordón", "corona", "correr", "coser", "cosmos", "costa", "cráneo", "cráter", "crear", "crecer", "creído", "crema", "cría", "crimen", "cripta", "crisis", "cromo", "crónica", "croqueta", "crudo", "cruz", "cuadro", "cuarto", "cuatro", "cubo", "cubrir", "cuchara", "cuello", "cuento", "cuerda", "cuesta", "cueva", "cuidar", "culebra", "culpa", "culto", "cumbre", "cumplir", "cuna", "cuneta", "cuota", "cupón", "cúpula", "curar", "curioso", "curso", "curva", "cutis", "dama", "danza", "dar", "dardo", "dátil", "deber", "débil", "década", "decir", "dedo", "defensa", "definir", "dejar", "delfín", "delgado", "delito", "demora", "denso", "dental", "deporte", "derecho", "derrota", "desayuno", "deseo", "desfile", "desnudo", "destino", "desvío", "detalle", "detener", "deuda", "día", "diablo", "diadema", "diamante", "diana", "diario", "dibujo", "dictar", "diente", "dieta", "diez", "difícil", "digno", "dilema", "diluir", "dinero", "directo", "dirigir", "disco", "diseño", "disfraz", "diva", "divino", "doble", "doce", "dolor", "domingo", "don", "donar", "dorado", "dormir", "dorso", "dos", "dosis", "dragón", "droga", "ducha", "duda", "duelo", "dueño", "dulce", "dúo", "duque", "durar", "dureza", "duro", "ébano", "ebrio", "echar", "eco", "ecuador", "edad", "edición", "edificio", "editor", "educar", "efecto", "eficaz", "eje", "ejemplo", "elefante", "elegir", "elemento", "elevar", "elipse", "élite", "elixir", "elogio", "eludir", "embudo", "emitir", "emoción", "empate", "empeño", "empleo", "empresa", "enano", "encargo", "enchufe", "encía", "enemigo", "enero", "enfado", "enfermo", "engaño", "enigma", "enlace", "enorme", "enredo", "ensayo", "enseñar", "entero", "entrar", "envase", "envío", "época", "equipo", "erizo", "escala", "escena", "escolar", "escribir", "escudo", "esencia", "esfera", "esfuerzo", "espada", "espejo", "espía", "esposa", "espuma", "esquí", "estar", "este", "estilo", "estufa", "etapa", "eterno", "ética", "etnia", "evadir", "evaluar", "evento", "evitar", "exacto", "examen", "exceso", "excusa", "exento", "exigir", "exilio", "existir", "éxito", "experto", "explicar", "exponer", "extremo", "fábrica", "fábula", "fachada", "fácil", "factor", "faena", "faja", "falda", "fallo", "falso", "faltar", "fama", "familia", "famoso", "faraón", "farmacia", "farol", "farsa", "fase", "fatiga", "fauna", "favor", "fax", "febrero", "fecha", "feliz", "feo", "feria", "feroz", "fértil", "fervor", "festín", "fiable", "fianza", "fiar", "fibra", "ficción", "ficha", "fideo", "fiebre", "fiel", "fiera", "fiesta", "figura", "fijar", "fijo", "fila", "filete", "filial", "filtro", "fin", "finca", "fingir", "finito", "firma", "flaco", "flauta", "flecha", "flor", "flota", "fluir", "flujo", "flúor", "fobia", "foca", "fogata", "fogón", "folio", "folleto", "fondo", "forma", "forro", "fortuna", "forzar", "fosa", "foto", "fracaso", "frágil", "franja", "frase", "fraude", "freír", "freno", "fresa", "frío", "frito", "fruta", "fuego", "fuente", "fuerza", "fuga", "fumar", "función", "funda", "furgón", "furia", "fusil", "fútbol", "futuro", "gacela", "gafas", "gaita", "gajo", "gala", "galería", "gallo", "gamba", "ganar", "gancho", "ganga", "ganso", "garaje", "garza", "gasolina", "gastar", "gato", "gavilán", "gemelo", "gemir", "gen", "género", "genio", "gente", "geranio", "gerente", "germen", "gesto", "gigante", "gimnasio", "girar", "giro", "glaciar", "globo", "gloria", "gol", "golfo", "goloso", "golpe", "goma", "gordo", "gorila", "gorra", "gota", "goteo", "gozar", "grada", "gráfico", "grano", "grasa", "gratis", "grave", "grieta", "grillo", "gripe", "gris", "grito", "grosor", "grúa", "grueso", "grumo", "grupo", "guante", "guapo", "guardia", "guerra", "guía", "guiño", "guion", "guiso", "guitarra", "gusano", "gustar", "haber", "hábil", "hablar", "hacer", "hacha", "hada", "hallar", "hamaca", "harina", "haz", "hazaña", "hebilla", "hebra", "hecho", "helado", "helio", "hembra", "herir", "hermano", "héroe", "hervir", "hielo", "hierro", "hígado", "higiene", "hijo", "himno", "historia", "hocico", "hogar", "hoguera", "hoja", "hombre", "hongo", "honor", "honra", "hora", "hormiga", "horno", "hostil", "hoyo", "hueco", "huelga", "huerta", "hueso", "huevo", "huida", "huir", "humano", "húmedo", "humilde", "humo", "hundir", "huracán", "hurto", "icono", "ideal", "idioma", "ídolo", "iglesia", "iglú", "igual", "ilegal", "ilusión", "imagen", "imán", "imitar", "impar", "imperio", "imponer", "impulso", "incapaz", "índice", "inerte", "infiel", "informe", "ingenio", "inicio", "inmenso", "inmune", "innato", "insecto", "instante", "interés", "íntimo", "intuir", "inútil", "invierno", "ira", "iris", "ironía", "isla", "islote", "jabalí", "jabón", "jamón", "jarabe", "jardín", "jarra", "jaula", "jazmín", "jefe", "jeringa", "jinete", "jornada", "joroba", "joven", "joya", "juerga", "jueves", "juez", "jugador", "jugo", "juguete", "juicio", "junco", "jungla", "junio", "juntar", "júpiter", "jurar", "justo", "juvenil", "juzgar", "kilo", "koala", "labio", "lacio", "lacra", "lado", "ladrón", "lagarto", "lágrima", "laguna", "laico", "lamer", "lámina", "lámpara", "lana", "lancha", "langosta", "lanza", "lápiz", "largo", "larva", "lástima", "lata", "látex", "latir", "laurel", "lavar", "lazo", "leal", "lección", "leche", "lector", "leer", "legión", "legumbre", "lejano", "lengua", "lento", "leña", "león", "leopardo", "lesión", "letal", "letra", "leve", "leyenda", "libertad", "libro", "licor", "líder", "lidiar", "lienzo", "liga", "ligero", "lima", "límite", "limón", "limpio", "lince", "lindo", "línea", "lingote", "lino", "linterna", "líquido", "liso", "lista", "litera", "litio", "litro", "llaga", "llama", "llanto", "llave", "llegar", "llenar", "llevar", "llorar", "llover", "lluvia", "lobo", "loción", "loco", "locura", "lógica", "logro", "lombriz", "lomo", "lonja", "lote", "lucha", "lucir", "lugar", "lujo", "luna", "lunes", "lupa", "lustro", "luto", "luz", "maceta", "macho", "madera", "madre", "maduro", "maestro", "mafia", "magia", "mago", "maíz", "maldad", "maleta", "malla", "malo", "mamá", "mambo", "mamut", "manco", "mando", "manejar", "manga", "maniquí", "manjar", "mano", "manso", "manta", "mañana", "mapa", "máquina", "mar", "marco", "marea", "marfil", "margen", "marido", "mármol", "marrón", "martes", "marzo", "masa", "máscara", "masivo", "matar", "materia", "matiz", "matriz", "máximo", "mayor", "mazorca", "mecha", "medalla", "medio", "médula", "mejilla", "mejor", "melena", "melón", "memoria", "menor", "mensaje", "mente", "menú", "mercado", "merengue", "mérito", "mes", "mesón", "meta", "meter", "método", "metro", "mezcla", "miedo", "miel", "miembro", "miga", "mil", "milagro", "militar", "millón", "mimo", "mina", "minero", "mínimo", "minuto", "miope", "mirar", "misa", "miseria", "misil", "mismo", "mitad", "mito", "mochila", "moción", "moda", "modelo", "moho", "mojar", "molde", "moler", "molino", "momento", "momia", "monarca", "moneda", "monja", "monto", "moño", "morada", "morder", "moreno", "morir", "morro", "morsa", "mortal", "mosca", "mostrar", "motivo", "mover", "móvil", "mozo", "mucho", "mudar", "mueble", "muela", "muerte", "muestra", "mugre", "mujer", "mula", "muleta", "multa", "mundo", "muñeca", "mural", "muro", "músculo", "museo", "musgo", "música", "muslo", "nácar", "nación", "nadar", "naipe", "naranja", "nariz", "narrar", "nasal", "natal", "nativo", "natural", "náusea", "naval", "nave", "navidad", "necio", "néctar", "negar", "negocio", "negro", "neón", "nervio", "neto", "neutro", "nevar", "nevera", "nicho", "nido", "niebla", "nieto", "niñez", "niño", "nítido", "nivel", "nobleza", "noche", "nómina", "noria", "norma", "norte", "nota", "noticia", "novato", "novela", "novio", "nube", "nuca", "núcleo", "nudillo", "nudo", "nuera", "nueve", "nuez", "nulo", "número", "nutria", "oasis", "obeso", "obispo", "objeto", "obra", "obrero", "observar", "obtener", "obvio", "oca", "ocaso", "océano", "ochenta", "ocho", "ocio", "ocre", "octavo", "octubre", "oculto", "ocupar", "ocurrir", "odiar", "odio", "odisea", "oeste", "ofensa", "oferta", "oficio", "ofrecer", "ogro", "oído", "oír", "ojo", "ola", "oleada", "olfato", "olivo", "olla", "olmo", "olor", "olvido", "ombligo", "onda", "onza", "opaco", "opción", "ópera", "opinar", "oponer", "optar", "óptica", "opuesto", "oración", "orador", "oral", "órbita", "orca", "orden", "oreja", "órgano", "orgía", "orgullo", "oriente", "origen", "orilla", "oro", "orquesta", "oruga", "osadía", "oscuro", "osezno", "oso", "ostra", "otoño", "otro", "oveja", "óvulo", "óxido", "oxígeno", "oyente", "ozono", "pacto", "padre", "paella", "página", "pago", "país", "pájaro", "palabra", "palco", "paleta", "pálido", "palma", "paloma", "palpar", "pan", "panal", "pánico", "pantera", "pañuelo", "papá", "papel", "papilla", "paquete", "parar", "parcela", "pared", "parir", "paro", "párpado", "parque", "párrafo", "parte", "pasar", "paseo", "pasión", "paso", "pasta", "pata", "patio", "patria", "pausa", "pauta", "pavo", "payaso", "peatón", "pecado", "pecera", "pecho", "pedal", "pedir", "pegar", "peine", "pelar", "peldaño", "pelea", "peligro", "pellejo", "pelo", "peluca", "pena", "pensar", "peñón", "peón", "peor", "pepino", "pequeño", "pera", "percha", "perder", "pereza", "perfil", "perico", "perla", "permiso", "perro", "persona", "pesa", "pesca", "pésimo", "pestaña", "pétalo", "petróleo", "pez", "pezuña", "picar", "pichón", "pie", "piedra", "pierna", "pieza", "pijama", "pilar", "piloto", "pimienta", "pino", "pintor", "pinza", "piña", "piojo", "pipa", "pirata", "pisar", "piscina", "piso", "pista", "pitón", "pizca", "placa", "plan", "plata", "playa", "plaza", "pleito", "pleno", "plomo", "pluma", "plural", "pobre", "poco", "poder", "podio", "poema", "poesía", "poeta", "polen", "policía", "pollo", "polvo", "pomada", "pomelo", "pomo", "pompa", "poner", "porción", "portal", "posada", "poseer", "posible", "poste", "potencia", "potro", "pozo", "prado", "precoz", "pregunta", "premio", "prensa", "preso", "previo", "primo", "príncipe", "prisión", "privar", "proa", "probar", "proceso", "producto", "proeza", "profesor", "programa", "prole", "promesa", "pronto", "propio", "próximo", "prueba", "público", "puchero", "pudor", "pueblo", "puerta", "puesto", "pulga", "pulir", "pulmón", "pulpo", "pulso", "puma", "punto", "puñal", "puño", "pupa", "pupila", "puré", "quedar", "queja", "quemar", "querer", "queso", "quieto", "química", "quince", "quitar", "rábano", "rabia", "rabo", "ración", "radical", "raíz", "rama", "rampa", "rancho", "rango", "rapaz", "rápido", "rapto", "rasgo", "raspa", "rato", "rayo", "raza", "razón", "reacción", "realidad", "rebaño", "rebote", "recaer", "receta", "rechazo", "recoger", "recreo", "recto", "recurso", "red", "redondo", "reducir", "reflejo", "reforma", "refrán", "refugio", "regalo", "regir", "regla", "regreso", "rehén", "reino", "reír", "reja", "relato", "relevo", "relieve", "relleno", "reloj", "remar", "remedio", "remo", "rencor", "rendir", "renta", "reparto", "repetir", "reposo", "reptil", "res", "rescate", "resina", "respeto", "resto", "resumen", "retiro", "retorno", "retrato", "reunir", "revés", "revista", "rey", "rezar", "rico", "riego", "rienda", "riesgo", "rifa", "rígido", "rigor", "rincón", "riñón", "río", "riqueza", "risa", "ritmo", "rito", "rizo", "roble", "roce", "rociar", "rodar", "rodeo", "rodilla", "roer", "rojizo", "rojo", "romero", "romper", "ron", "ronco", "ronda", "ropa", "ropero", "rosa", "rosca", "rostro", "rotar", "rubí", "rubor", "rudo", "rueda", "rugir", "ruido", "ruina", "ruleta", "rulo", "rumbo", "rumor", "ruptura", "ruta", "rutina", "sábado", "saber", "sabio", "sable", "sacar", "sagaz", "sagrado", "sala", "saldo", "salero", "salir", "salmón", "salón", "salsa", "salto", "salud", "salvar", "samba", "sanción", "sandía", "sanear", "sangre", "sanidad", "sano", "santo", "sapo", "saque", "sardina", "sartén", "sastre", "satán", "sauna", "saxofón", "sección", "seco", "secreto", "secta", "sed", "seguir", "seis", "sello", "selva", "semana", "semilla", "senda", "sensor", "señal", "señor", "separar", "sepia", "sequía", "ser", "serie", "sermón", "servir", "sesenta", "sesión", "seta", "setenta", "severo", "sexo", "sexto", "sidra", "siesta", "siete", "siglo", "signo", "sílaba", "silbar", "silencio", "silla", "símbolo", "simio", "sirena", "sistema", "sitio", "situar", "sobre", "socio", "sodio", "sol", "solapa", "soldado", "soledad", "sólido", "soltar", "solución", "sombra", "sondeo", "sonido", "sonoro", "sonrisa", "sopa", "soplar", "soporte", "sordo", "sorpresa", "sorteo", "sostén", "sótano", "suave", "subir", "suceso", "sudor", "suegra", "suelo", "sueño", "suerte", "sufrir", "sujeto", "sultán", "sumar", "superar", "suplir", "suponer", "supremo", "sur", "surco", "sureño", "surgir", "susto", "sutil", "tabaco", "tabique", "tabla", "tabú", "taco", "tacto", "tajo", "talar", "talco", "talento", "talla", "talón", "tamaño", "tambor", "tango", "tanque", "tapa", "tapete", "tapia", "tapón", "taquilla", "tarde", "tarea", "tarifa", "tarjeta", "tarot", "tarro", "tarta", "tatuaje", "tauro", "taza", "tazón", "teatro", "techo", "tecla", "técnica", "tejado", "tejer", "tejido", "tela", "teléfono", "tema", "temor", "templo", "tenaz", "tender", "tener", "tenis", "tenso", "teoría", "terapia", "terco", "término", "ternura", "terror", "tesis", "tesoro", "testigo", "tetera", "texto", "tez", "tibio", "tiburón", "tiempo", "tienda", "tierra", "tieso", "tigre", "tijera", "tilde", "timbre", "tímido", "timo", "tinta", "tío", "típico", "tipo", "tira", "tirón", "titán", "títere", "título", "tiza", "toalla", "tobillo", "tocar", "tocino", "todo", "toga", "toldo", "tomar", "tono", "tonto", "topar", "tope", "toque", "tórax", "torero", "tormenta", "torneo", "toro", "torpedo", "torre", "torso", "tortuga", "tos", "tosco", "toser", "tóxico", "trabajo", "tractor", "traer", "tráfico", "trago", "traje", "tramo", "trance", "trato", "trauma", "trazar", "trébol", "tregua", "treinta", "tren", "trepar", "tres", "tribu", "trigo", "tripa", "triste", "triunfo", "trofeo", "trompa", "tronco", "tropa", "trote", "trozo", "truco", "trueno", "trufa", "tubería", "tubo", "tuerto", "tumba", "tumor", "túnel", "túnica", "turbina", "turismo", "turno", "tutor", "ubicar", "úlcera", "umbral", "unidad", "unir", "universo", "uno", "untar", "uña", "urbano", "urbe", "urgente", "urna", "usar", "usuario", "útil", "utopía", "uva", "vaca", "vacío", "vacuna", "vagar", "vago", "vaina", "vajilla", "vale", "válido", "valle", "valor", "válvula", "vampiro", "vara", "variar", "varón", "vaso", "vecino", "vector", "vehículo", "veinte", "vejez", "vela", "velero", "veloz", "vena", "vencer", "venda", "veneno", "vengar", "venir", "venta", "venus", "ver", "verano", "verbo", "verde", "vereda", "verja", "verso", "verter", "vía", "viaje", "vibrar", "vicio", "víctima", "vida", "vídeo", "vidrio", "viejo", "viernes", "vigor", "vil", "villa", "vinagre", "vino", "viñedo", "violín", "viral", "virgo", "virtud", "visor", "víspera", "vista", "vitamina", "viudo", "vivaz", "vivero", "vivir", "vivo", "volcán", "volumen", "volver", "voraz", "votar", "voto", "voz", "vuelo", "vulgar", "yacer", "yate", "yegua", "yema", "yerno", "yeso", "yodo", "yoga", "yogur", "zafiro", "zanja", "zapato", "zarza", "zona", "zorro", "zumo", "zurdo" };
 
+        /// <summary>
+        /// Spanish Constructor
+        /// </summary>
         public Spanish() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Portuguese Words
+    /// </summary>
     public class Portuguese : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "abacate", "abaixo", "abalar", "abater", "abduzir", "abelha", "aberto", "abismo", "abotoar", "abranger", "abreviar", "abrigar", "abrupto", "absinto", "absoluto", "absurdo", "abutre", "acabado", "acalmar", "acampar", "acanhar", "acaso", "aceitar", "acelerar", "acenar", "acervo", "acessar", "acetona", "achatar", "acidez", "acima", "acionado", "acirrar", "aclamar", "aclive", "acolhida", "acomodar", "acoplar", "acordar", "acumular", "acusador", "adaptar", "adega", "adentro", "adepto", "adequar", "aderente", "adesivo", "adeus", "adiante", "aditivo", "adjetivo", "adjunto", "admirar", "adorar", "adquirir", "adubo", "adverso", "advogado", "aeronave", "afastar", "aferir", "afetivo", "afinador", "afivelar", "aflito", "afluente", "afrontar", "agachar", "agarrar", "agasalho", "agenciar", "agilizar", "agiota", "agitado", "agora", "agradar", "agreste", "agrupar", "aguardar", "agulha", "ajoelhar", "ajudar", "ajustar", "alameda", "alarme", "alastrar", "alavanca", "albergue", "albino", "alcatra", "aldeia", "alecrim", "alegria", "alertar", "alface", "alfinete", "algum", "alheio", "aliar", "alicate", "alienar", "alinhar", "aliviar", "almofada", "alocar", "alpiste", "alterar", "altitude", "alucinar", "alugar", "aluno", "alusivo", "alvo", "amaciar", "amador", "amarelo", "amassar", "ambas", "ambiente", "ameixa", "amenizar", "amido", "amistoso", "amizade", "amolador", "amontoar", "amoroso", "amostra", "amparar", "ampliar", "ampola", "anagrama", "analisar", "anarquia", "anatomia", "andaime", "anel", "anexo", "angular", "animar", "anjo", "anomalia", "anotado", "ansioso", "anterior", "anuidade", "anunciar", "anzol", "apagador", "apalpar", "apanhado", "apego", "apelido", "apertada", "apesar", "apetite", "apito", "aplauso", "aplicada", "apoio", "apontar", "aposta", "aprendiz", "aprovar", "aquecer", "arame", "aranha", "arara", "arcada", "ardente", "areia", "arejar", "arenito", "aresta", "argiloso", "argola", "arma", "arquivo", "arraial", "arrebate", "arriscar", "arroba", "arrumar", "arsenal", "arterial", "artigo", "arvoredo", "asfaltar", "asilado", "aspirar", "assador", "assinar", "assoalho", "assunto", "astral", "atacado", "atadura", "atalho", "atarefar", "atear", "atender", "aterro", "ateu", "atingir", "atirador", "ativo", "atoleiro", "atracar", "atrevido", "atriz", "atual", "atum", "auditor", "aumentar", "aura", "aurora", "autismo", "autoria", "autuar", "avaliar", "avante", "avaria", "avental", "avesso", "aviador", "avisar", "avulso", "axila", "azarar", "azedo", "azeite", "azulejo", "babar", "babosa", "bacalhau", "bacharel", "bacia", "bagagem", "baiano", "bailar", "baioneta", "bairro", "baixista", "bajular", "baleia", "baliza", "balsa", "banal", "bandeira", "banho", "banir", "banquete", "barato", "barbado", "baronesa", "barraca", "barulho", "baseado", "bastante", "batata", "batedor", "batida", "batom", "batucar", "baunilha", "beber", "beijo", "beirada", "beisebol", "beldade", "beleza", "belga", "beliscar", "bendito", "bengala", "benzer", "berimbau", "berlinda", "berro", "besouro", "bexiga", "bezerro", "bico", "bicudo", "bienal", "bifocal", "bifurcar", "bigorna", "bilhete", "bimestre", "bimotor", "biologia", "biombo", "biosfera", "bipolar", "birrento", "biscoito", "bisneto", "bispo", "bissexto", "bitola", "bizarro", "blindado", "bloco", "bloquear", "boato", "bobagem", "bocado", "bocejo", "bochecha", "boicotar", "bolada", "boletim", "bolha", "bolo", "bombeiro", "bonde", "boneco", "bonita", "borbulha", "borda", "boreal", "borracha", "bovino", "boxeador", "branco", "brasa", "braveza", "breu", "briga", "brilho", "brincar", "broa", "brochura", "bronzear", "broto", "bruxo", "bucha", "budismo", "bufar", "bule", "buraco", "busca", "busto", "buzina", "cabana", "cabelo", "cabide", "cabo", "cabrito", "cacau", "cacetada", "cachorro", "cacique", "cadastro", "cadeado", "cafezal", "caiaque", "caipira", "caixote", "cajado", "caju", "calafrio", "calcular", "caldeira", "calibrar", "calmante", "calota", "camada", "cambista", "camisa", "camomila", "campanha", "camuflar", "canavial", "cancelar", "caneta", "canguru", "canhoto", "canivete", "canoa", "cansado", "cantar", "canudo", "capacho", "capela", "capinar", "capotar", "capricho", "captador", "capuz", "caracol", "carbono", "cardeal", "careca", "carimbar", "carneiro", "carpete", "carreira", "cartaz", "carvalho", "casaco", "casca", "casebre", "castelo", "casulo", "catarata", "cativar", "caule", "causador", "cautelar", "cavalo", "caverna", "cebola", "cedilha", "cegonha", "celebrar", "celular", "cenoura", "censo", "centeio", "cercar", "cerrado", "certeiro", "cerveja", "cetim", "cevada", "chacota", "chaleira", "chamado", "chapada", "charme", "chatice", "chave", "chefe", "chegada", "cheiro", "cheque", "chicote", "chifre", "chinelo", "chocalho", "chover", "chumbo", "chutar", "chuva", "cicatriz", "ciclone", "cidade", "cidreira", "ciente", "cigana", "cimento", "cinto", "cinza", "ciranda", "circuito", "cirurgia", "citar", "clareza", "clero", "clicar", "clone", "clube", "coado", "coagir", "cobaia", "cobertor", "cobrar", "cocada", "coelho", "coentro", "coeso", "cogumelo", "coibir", "coifa", "coiote", "colar", "coleira", "colher", "colidir", "colmeia", "colono", "coluna", "comando", "combinar", "comentar", "comitiva", "comover", "complexo", "comum", "concha", "condor", "conectar", "confuso", "congelar", "conhecer", "conjugar", "consumir", "contrato", "convite", "cooperar", "copeiro", "copiador", "copo", "coquetel", "coragem", "cordial", "corneta", "coronha", "corporal", "correio", "cortejo", "coruja", "corvo", "cosseno", "costela", "cotonete", "couro", "couve", "covil", "cozinha", "cratera", "cravo", "creche", "credor", "creme", "crer", "crespo", "criada", "criminal", "crioulo", "crise", "criticar", "crosta", "crua", "cruzeiro", "cubano", "cueca", "cuidado", "cujo", "culatra", "culminar", "culpar", "cultura", "cumprir", "cunhado", "cupido", "curativo", "curral", "cursar", "curto", "cuspir", "custear", "cutelo", "damasco", "datar", "debater", "debitar", "deboche", "debulhar", "decalque", "decimal", "declive", "decote", "decretar", "dedal", "dedicado", "deduzir", "defesa", "defumar", "degelo", "degrau", "degustar", "deitado", "deixar", "delator", "delegado", "delinear", "delonga", "demanda", "demitir", "demolido", "dentista", "depenado", "depilar", "depois", "depressa", "depurar", "deriva", "derramar", "desafio", "desbotar", "descanso", "desenho", "desfiado", "desgaste", "desigual", "deslize", "desmamar", "desova", "despesa", "destaque", "desviar", "detalhar", "detentor", "detonar", "detrito", "deusa", "dever", "devido", "devotado", "dezena", "diagrama", "dialeto", "didata", "difuso", "digitar", "dilatado", "diluente", "diminuir", "dinastia", "dinheiro", "diocese", "direto", "discreta", "disfarce", "disparo", "disquete", "dissipar", "distante", "ditador", "diurno", "diverso", "divisor", "divulgar", "dizer", "dobrador", "dolorido", "domador", "dominado", "donativo", "donzela", "dormente", "dorsal", "dosagem", "dourado", "doutor", "drenagem", "drible", "drogaria", "duelar", "duende", "dueto", "duplo", "duquesa", "durante", "duvidoso", "eclodir", "ecoar", "ecologia", "edificar", "edital", "educado", "efeito", "efetivar", "ejetar", "elaborar", "eleger", "eleitor", "elenco", "elevador", "eliminar", "elogiar", "embargo", "embolado", "embrulho", "embutido", "emenda", "emergir", "emissor", "empatia", "empenho", "empinado", "empolgar", "emprego", "empurrar", "emulador", "encaixe", "encenado", "enchente", "encontro", "endeusar", "endossar", "enfaixar", "enfeite", "enfim", "engajado", "engenho", "englobar", "engomado", "engraxar", "enguia", "enjoar", "enlatar", "enquanto", "enraizar", "enrolado", "enrugar", "ensaio", "enseada", "ensino", "ensopado", "entanto", "enteado", "entidade", "entortar", "entrada", "entulho", "envergar", "enviado", "envolver", "enxame", "enxerto", "enxofre", "enxuto", "epiderme", "equipar", "ereto", "erguido", "errata", "erva", "ervilha", "esbanjar", "esbelto", "escama", "escola", "escrita", "escuta", "esfinge", "esfolar", "esfregar", "esfumado", "esgrima", "esmalte", "espanto", "espelho", "espiga", "esponja", "espreita", "espumar", "esquerda", "estaca", "esteira", "esticar", "estofado", "estrela", "estudo", "esvaziar", "etanol", "etiqueta", "euforia", "europeu", "evacuar", "evaporar", "evasivo", "eventual", "evidente", "evoluir", "exagero", "exalar", "examinar", "exato", "exausto", "excesso", "excitar", "exclamar", "executar", "exemplo", "exibir", "exigente", "exonerar", "expandir", "expelir", "expirar", "explanar", "exposto", "expresso", "expulsar", "externo", "extinto", "extrato", "fabricar", "fabuloso", "faceta", "facial", "fada", "fadiga", "faixa", "falar", "falta", "familiar", "fandango", "fanfarra", "fantoche", "fardado", "farelo", "farinha", "farofa", "farpa", "fartura", "fatia", "fator", "favorita", "faxina", "fazenda", "fechado", "feijoada", "feirante", "felino", "feminino", "fenda", "feno", "fera", "feriado", "ferrugem", "ferver", "festejar", "fetal", "feudal", "fiapo", "fibrose", "ficar", "ficheiro", "figurado", "fileira", "filho", "filme", "filtrar", "firmeza", "fisgada", "fissura", "fita", "fivela", "fixador", "fixo", "flacidez", "flamingo", "flanela", "flechada", "flora", "flutuar", "fluxo", "focal", "focinho", "fofocar", "fogo", "foguete", "foice", "folgado", "folheto", "forjar", "formiga", "forno", "forte", "fosco", "fossa", "fragata", "fralda", "frango", "frasco", "fraterno", "freira", "frente", "fretar", "frieza", "friso", "fritura", "fronha", "frustrar", "fruteira", "fugir", "fulano", "fuligem", "fundar", "fungo", "funil", "furador", "furioso", "futebol", "gabarito", "gabinete", "gado", "gaiato", "gaiola", "gaivota", "galega", "galho", "galinha", "galocha", "ganhar", "garagem", "garfo", "gargalo", "garimpo", "garoupa", "garrafa", "gasoduto", "gasto", "gata", "gatilho", "gaveta", "gazela", "gelado", "geleia", "gelo", "gemada", "gemer", "gemido", "generoso", "gengiva", "genial", "genoma", "genro", "geologia", "gerador", "germinar", "gesso", "gestor", "ginasta", "gincana", "gingado", "girafa", "girino", "glacial", "glicose", "global", "glorioso", "goela", "goiaba", "golfe", "golpear", "gordura", "gorjeta", "gorro", "gostoso", "goteira", "governar", "gracejo", "gradual", "grafite", "gralha", "grampo", "granada", "gratuito", "graveto", "graxa", "grego", "grelhar", "greve", "grilo", "grisalho", "gritaria", "grosso", "grotesco", "grudado", "grunhido", "gruta", "guache", "guarani", "guaxinim", "guerrear", "guiar", "guincho", "guisado", "gula", "guloso", "guru", "habitar", "harmonia", "haste", "haver", "hectare", "herdar", "heresia", "hesitar", "hiato", "hibernar", "hidratar", "hiena", "hino", "hipismo", "hipnose", "hipoteca", "hoje", "holofote", "homem", "honesto", "honrado", "hormonal", "hospedar", "humorado", "iate", "ideia", "idoso", "ignorado", "igreja", "iguana", "ileso", "ilha", "iludido", "iluminar", "ilustrar", "imagem", "imediato", "imenso", "imersivo", "iminente", "imitador", "imortal", "impacto", "impedir", "implante", "impor", "imprensa", "impune", "imunizar", "inalador", "inapto", "inativo", "incenso", "inchar", "incidir", "incluir", "incolor", "indeciso", "indireto", "indutor", "ineficaz", "inerente", "infantil", "infestar", "infinito", "inflamar", "informal", "infrator", "ingerir", "inibido", "inicial", "inimigo", "injetar", "inocente", "inodoro", "inovador", "inox", "inquieto", "inscrito", "inseto", "insistir", "inspetor", "instalar", "insulto", "intacto", "integral", "intimar", "intocado", "intriga", "invasor", "inverno", "invicto", "invocar", "iogurte", "iraniano", "ironizar", "irreal", "irritado", "isca", "isento", "isolado", "isqueiro", "italiano", "janeiro", "jangada", "janta", "jararaca", "jardim", "jarro", "jasmim", "jato", "javali", "jazida", "jejum", "joaninha", "joelhada", "jogador", "joia", "jornal", "jorrar", "jovem", "juba", "judeu", "judoca", "juiz", "julgador", "julho", "jurado", "jurista", "juro", "justa", "labareda", "laboral", "lacre", "lactante", "ladrilho", "lagarta", "lagoa", "laje", "lamber", "lamentar", "laminar", "lampejo", "lanche", "lapidar", "lapso", "laranja", "lareira", "largura", "lasanha", "lastro", "lateral", "latido", "lavanda", "lavoura", "lavrador", "laxante", "lazer", "lealdade", "lebre", "legado", "legendar", "legista", "leigo", "leiloar", "leitura", "lembrete", "leme", "lenhador", "lentilha", "leoa", "lesma", "leste", "letivo", "letreiro", "levar", "leveza", "levitar", "liberal", "libido", "liderar", "ligar", "ligeiro", "limitar", "limoeiro", "limpador", "linda", "linear", "linhagem", "liquidez", "listagem", "lisura", "litoral", "livro", "lixa", "lixeira", "locador", "locutor", "lojista", "lombo", "lona", "longe", "lontra", "lorde", "lotado", "loteria", "loucura", "lousa", "louvar", "luar", "lucidez", "lucro", "luneta", "lustre", "lutador", "luva", "macaco", "macete", "machado", "macio", "madeira", "madrinha", "magnata", "magreza", "maior", "mais", "malandro", "malha", "malote", "maluco", "mamilo", "mamoeiro", "mamute", "manada", "mancha", "mandato", "manequim", "manhoso", "manivela", "manobrar", "mansa", "manter", "manusear", "mapeado", "maquinar", "marcador", "maresia", "marfim", "margem", "marinho", "marmita", "maroto", "marquise", "marreco", "martelo", "marujo", "mascote", "masmorra", "massagem", "mastigar", "matagal", "materno", "matinal", "matutar", "maxilar", "medalha", "medida", "medusa", "megafone", "meiga", "melancia", "melhor", "membro", "memorial", "menino", "menos", "mensagem", "mental", "merecer", "mergulho", "mesada", "mesclar", "mesmo", "mesquita", "mestre", "metade", "meteoro", "metragem", "mexer", "mexicano", "micro", "migalha", "migrar", "milagre", "milenar", "milhar", "mimado", "minerar", "minhoca", "ministro", "minoria", "miolo", "mirante", "mirtilo", "misturar", "mocidade", "moderno", "modular", "moeda", "moer", "moinho", "moita", "moldura", "moleza", "molho", "molinete", "molusco", "montanha", "moqueca", "morango", "morcego", "mordomo", "morena", "mosaico", "mosquete", "mostarda", "motel", "motim", "moto", "motriz", "muda", "muito", "mulata", "mulher", "multar", "mundial", "munido", "muralha", "murcho", "muscular", "museu", "musical", "nacional", "nadador", "naja", "namoro", "narina", "narrado", "nascer", "nativa", "natureza", "navalha", "navegar", "navio", "neblina", "nebuloso", "negativa", "negociar", "negrito", "nervoso", "neta", "neural", "nevasca", "nevoeiro", "ninar", "ninho", "nitidez", "nivelar", "nobreza", "noite", "noiva", "nomear", "nominal", "nordeste", "nortear", "notar", "noticiar", "noturno", "novelo", "novilho", "novo", "nublado", "nudez", "numeral", "nupcial", "nutrir", "nuvem", "obcecado", "obedecer", "objetivo", "obrigado", "obscuro", "obstetra", "obter", "obturar", "ocidente", "ocioso", "ocorrer", "oculista", "ocupado", "ofegante", "ofensiva", "oferenda", "oficina", "ofuscado", "ogiva", "olaria", "oleoso", "olhar", "oliveira", "ombro", "omelete", "omisso", "omitir", "ondulado", "oneroso", "ontem", "opcional", "operador", "oponente", "oportuno", "oposto", "orar", "orbitar", "ordem", "ordinal", "orfanato", "orgasmo", "orgulho", "oriental", "origem", "oriundo", "orla", "ortodoxo", "orvalho", "oscilar", "ossada", "osso", "ostentar", "otimismo", "ousadia", "outono", "outubro", "ouvido", "ovelha", "ovular", "oxidar", "oxigenar", "pacato", "paciente", "pacote", "pactuar", "padaria", "padrinho", "pagar", "pagode", "painel", "pairar", "paisagem", "palavra", "palestra", "palheta", "palito", "palmada", "palpitar", "pancada", "panela", "panfleto", "panqueca", "pantanal", "papagaio", "papelada", "papiro", "parafina", "parcial", "pardal", "parede", "partida", "pasmo", "passado", "pastel", "patamar", "patente", "patinar", "patrono", "paulada", "pausar", "peculiar", "pedalar", "pedestre", "pediatra", "pedra", "pegada", "peitoral", "peixe", "pele", "pelicano", "penca", "pendurar", "peneira", "penhasco", "pensador", "pente", "perceber", "perfeito", "pergunta", "perito", "permitir", "perna", "perplexo", "persiana", "pertence", "peruca", "pescado", "pesquisa", "pessoa", "petiscar", "piada", "picado", "piedade", "pigmento", "pilastra", "pilhado", "pilotar", "pimenta", "pincel", "pinguim", "pinha", "pinote", "pintar", "pioneiro", "pipoca", "piquete", "piranha", "pires", "pirueta", "piscar", "pistola", "pitanga", "pivete", "planta", "plaqueta", "platina", "plebeu", "plumagem", "pluvial", "pneu", "poda", "poeira", "poetisa", "polegada", "policiar", "poluente", "polvilho", "pomar", "pomba", "ponderar", "pontaria", "populoso", "porta", "possuir", "postal", "pote", "poupar", "pouso", "povoar", "praia", "prancha", "prato", "praxe", "prece", "predador", "prefeito", "premiar", "prensar", "preparar", "presilha", "pretexto", "prevenir", "prezar", "primata", "princesa", "prisma", "privado", "processo", "produto", "profeta", "proibido", "projeto", "prometer", "propagar", "prosa", "protetor", "provador", "publicar", "pudim", "pular", "pulmonar", "pulseira", "punhal", "punir", "pupilo", "pureza", "puxador", "quadra", "quantia", "quarto", "quase", "quebrar", "queda", "queijo", "quente", "querido", "quimono", "quina", "quiosque", "rabanada", "rabisco", "rachar", "racionar", "radial", "raiar", "rainha", "raio", "raiva", "rajada", "ralado", "ramal", "ranger", "ranhura", "rapadura", "rapel", "rapidez", "raposa", "raquete", "raridade", "rasante", "rascunho", "rasgar", "raspador", "rasteira", "rasurar", "ratazana", "ratoeira", "realeza", "reanimar", "reaver", "rebaixar", "rebelde", "rebolar", "recado", "recente", "recheio", "recibo", "recordar", "recrutar", "recuar", "rede", "redimir", "redonda", "reduzida", "reenvio", "refinar", "refletir", "refogar", "refresco", "refugiar", "regalia", "regime", "regra", "reinado", "reitor", "rejeitar", "relativo", "remador", "remendo", "remorso", "renovado", "reparo", "repelir", "repleto", "repolho", "represa", "repudiar", "requerer", "resenha", "resfriar", "resgatar", "residir", "resolver", "respeito", "ressaca", "restante", "resumir", "retalho", "reter", "retirar", "retomada", "retratar", "revelar", "revisor", "revolta", "riacho", "rica", "rigidez", "rigoroso", "rimar", "ringue", "risada", "risco", "risonho", "robalo", "rochedo", "rodada", "rodeio", "rodovia", "roedor", "roleta", "romano", "roncar", "rosado", "roseira", "rosto", "rota", "roteiro", "rotina", "rotular", "rouco", "roupa", "roxo", "rubro", "rugido", "rugoso", "ruivo", "rumo", "rupestre", "russo", "sabor", "saciar", "sacola", "sacudir", "sadio", "safira", "saga", "sagrada", "saibro", "salada", "saleiro", "salgado", "saliva", "salpicar", "salsicha", "saltar", "salvador", "sambar", "samurai", "sanar", "sanfona", "sangue", "sanidade", "sapato", "sarda", "sargento", "sarjeta", "saturar", "saudade", "saxofone", "sazonal", "secar", "secular", "seda", "sedento", "sediado", "sedoso", "sedutor", "segmento", "segredo", "segundo", "seiva", "seleto", "selvagem", "semanal", "semente", "senador", "senhor", "sensual", "sentado", "separado", "sereia", "seringa", "serra", "servo", "setembro", "setor", "sigilo", "silhueta", "silicone", "simetria", "simpatia", "simular", "sinal", "sincero", "singular", "sinopse", "sintonia", "sirene", "siri", "situado", "soberano", "sobra", "socorro", "sogro", "soja", "solda", "soletrar", "solteiro", "sombrio", "sonata", "sondar", "sonegar", "sonhador", "sono", "soprano", "soquete", "sorrir", "sorteio", "sossego", "sotaque", "soterrar", "sovado", "sozinho", "suavizar", "subida", "submerso", "subsolo", "subtrair", "sucata", "sucesso", "suco", "sudeste", "sufixo", "sugador", "sugerir", "sujeito", "sulfato", "sumir", "suor", "superior", "suplicar", "suposto", "suprimir", "surdina", "surfista", "surpresa", "surreal", "surtir", "suspiro", "sustento", "tabela", "tablete", "tabuada", "tacho", "tagarela", "talher", "talo", "talvez", "tamanho", "tamborim", "tampa", "tangente", "tanto", "tapar", "tapioca", "tardio", "tarefa", "tarja", "tarraxa", "tatuagem", "taurino", "taxativo", "taxista", "teatral", "tecer", "tecido", "teclado", "tedioso", "teia", "teimar", "telefone", "telhado", "tempero", "tenente", "tensor", "tentar", "termal", "terno", "terreno", "tese", "tesoura", "testado", "teto", "textura", "texugo", "tiara", "tigela", "tijolo", "timbrar", "timidez", "tingido", "tinteiro", "tiragem", "titular", "toalha", "tocha", "tolerar", "tolice", "tomada", "tomilho", "tonel", "tontura", "topete", "tora", "torcido", "torneio", "torque", "torrada", "torto", "tostar", "touca", "toupeira", "toxina", "trabalho", "tracejar", "tradutor", "trafegar", "trajeto", "trama", "trancar", "trapo", "traseiro", "tratador", "travar", "treino", "tremer", "trepidar", "trevo", "triagem", "tribo", "triciclo", "tridente", "trilogia", "trindade", "triplo", "triturar", "triunfal", "trocar", "trombeta", "trova", "trunfo", "truque", "tubular", "tucano", "tudo", "tulipa", "tupi", "turbo", "turma", "turquesa", "tutelar", "tutorial", "uivar", "umbigo", "unha", "unidade", "uniforme", "urologia", "urso", "urtiga", "urubu", "usado", "usina", "usufruir", "vacina", "vadiar", "vagaroso", "vaidoso", "vala", "valente", "validade", "valores", "vantagem", "vaqueiro", "varanda", "vareta", "varrer", "vascular", "vasilha", "vassoura", "vazar", "vazio", "veado", "vedar", "vegetar", "veicular", "veleiro", "velhice", "veludo", "vencedor", "vendaval", "venerar", "ventre", "verbal", "verdade", "vereador", "vergonha", "vermelho", "verniz", "versar", "vertente", "vespa", "vestido", "vetorial", "viaduto", "viagem", "viajar", "viatura", "vibrador", "videira", "vidraria", "viela", "viga", "vigente", "vigiar", "vigorar", "vilarejo", "vinco", "vinheta", "vinil", "violeta", "virada", "virtude", "visitar", "visto", "vitral", "viveiro", "vizinho", "voador", "voar", "vogal", "volante", "voleibol", "voltagem", "volumoso", "vontade", "vulto", "vuvuzela", "xadrez", "xarope", "xeque", "xeretar", "xerife", "xingar", "zangado", "zarpar", "zebu", "zelador", "zombar", "zoologia", "zumbido" };
 
+        /// <summary>
+        /// Portuguese Constructor
+        /// </summary>
         public Portuguese() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Czech Words
+    /// </summary>
     public class Czech : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "abdikace", "abeceda", "adresa", "agrese", "akce", "aktovka", "alej", "alkohol", "amputace", "ananas", "andulka", "anekdota", "anketa", "antika", "anulovat", "archa", "arogance", "asfalt", "asistent", "aspirace", "astma", "astronom", "atlas", "atletika", "atol", "autobus", "azyl", "babka", "bachor", "bacil", "baculka", "badatel", "bageta", "bagr", "bahno", "bakterie", "balada", "baletka", "balkon", "balonek", "balvan", "balza", "bambus", "bankomat", "barbar", "baret", "barman", "baroko", "barva", "baterka", "batoh", "bavlna", "bazalka", "bazilika", "bazuka", "bedna", "beran", "beseda", "bestie", "beton", "bezinka", "bezmoc", "beztak", "bicykl", "bidlo", "biftek", "bikiny", "bilance", "biograf", "biolog", "bitva", "bizon", "blahobyt", "blatouch", "blecha", "bledule", "blesk", "blikat", "blizna", "blokovat", "bloudit", "blud", "bobek", "bobr", "bodlina", "bodnout", "bohatost", "bojkot", "bojovat", "bokorys", "bolest", "borec", "borovice", "bota", "boubel", "bouchat", "bouda", "boule", "bourat", "boxer", "bradavka", "brambora", "branka", "bratr", "brepta", "briketa", "brko", "brloh", "bronz", "broskev", "brunetka", "brusinka", "brzda", "brzy", "bublina", "bubnovat", "buchta", "buditel", "budka", "budova", "bufet", "bujarost", "bukvice", "buldok", "bulva", "bunda", "bunkr", "burza", "butik", "buvol", "buzola", "bydlet", "bylina", "bytovka", "bzukot", "capart", "carevna", "cedr", "cedule", "cejch", "cejn", "cela", "celer", "celkem", "celnice", "cenina", "cennost", "cenovka", "centrum", "cenzor", "cestopis", "cetka", "chalupa", "chapadlo", "charita", "chata", "chechtat", "chemie", "chichot", "chirurg", "chlad", "chleba", "chlubit", "chmel", "chmura", "chobot", "chochol", "chodba", "cholera", "chomout", "chopit", "choroba", "chov", "chrapot", "chrlit", "chrt", "chrup", "chtivost", "chudina", "chutnat", "chvat", "chvilka", "chvost", "chyba", "chystat", "chytit", "cibule", "cigareta", "cihelna", "cihla", "cinkot", "cirkus", "cisterna", "citace", "citrus", "cizinec", "cizost", "clona", "cokoliv", "couvat", "ctitel", "ctnost", "cudnost", "cuketa", "cukr", "cupot", "cvaknout", "cval", "cvik", "cvrkot", "cyklista", "daleko", "dareba", "datel", "datum", "dcera", "debata", "dechovka", "decibel", "deficit", "deflace", "dekl", "dekret", "demokrat", "deprese", "derby", "deska", "detektiv", "dikobraz", "diktovat", "dioda", "diplom", "disk", "displej", "divadlo", "divoch", "dlaha", "dlouho", "dluhopis", "dnes", "dobro", "dobytek", "docent", "dochutit", "dodnes", "dohled", "dohoda", "dohra", "dojem", "dojnice", "doklad", "dokola", "doktor", "dokument", "dolar", "doleva", "dolina", "doma", "dominant", "domluvit", "domov", "donutit", "dopad", "dopis", "doplnit", "doposud", "doprovod", "dopustit", "dorazit", "dorost", "dort", "dosah", "doslov", "dostatek", "dosud", "dosyta", "dotaz", "dotek", "dotknout", "doufat", "doutnat", "dovozce", "dozadu", "doznat", "dozorce", "drahota", "drak", "dramatik", "dravec", "draze", "drdol", "drobnost", "drogerie", "drozd", "drsnost", "drtit", "drzost", "duben", "duchovno", "dudek", "duha", "duhovka", "dusit", "dusno", "dutost", "dvojice", "dvorec", "dynamit", "ekolog", "ekonomie", "elektron", "elipsa", "email", "emise", "emoce", "empatie", "epizoda", "epocha", "epopej", "epos", "esej", "esence", "eskorta", "eskymo", "etiketa", "euforie", "evoluce", "exekuce", "exkurze", "expedice", "exploze", "export", "extrakt", "facka", "fajfka", "fakulta", "fanatik", "fantazie", "farmacie", "favorit", "fazole", "federace", "fejeton", "fenka", "fialka", "figurant", "filozof", "filtr", "finance", "finta", "fixace", "fjord", "flanel", "flirt", "flotila", "fond", "fosfor", "fotbal", "fotka", "foton", "frakce", "freska", "fronta", "fukar", "funkce", "fyzika", "galeje", "garant", "genetika", "geolog", "gilotina", "glazura", "glejt", "golem", "golfista", "gotika", "graf", "gramofon", "granule", "grep", "gril", "grog", "groteska", "guma", "hadice", "hadr", "hala", "halenka", "hanba", "hanopis", "harfa", "harpuna", "havran", "hebkost", "hejkal", "hejno", "hejtman", "hektar", "helma", "hematom", "herec", "herna", "heslo", "hezky", "historik", "hladovka", "hlasivky", "hlava", "hledat", "hlen", "hlodavec", "hloh", "hloupost", "hltat", "hlubina", "hluchota", "hmat", "hmota", "hmyz", "hnis", "hnojivo", "hnout", "hoblina", "hoboj", "hoch", "hodiny", "hodlat", "hodnota", "hodovat", "hojnost", "hokej", "holinka", "holka", "holub", "homole", "honitba", "honorace", "horal", "horda", "horizont", "horko", "horlivec", "hormon", "hornina", "horoskop", "horstvo", "hospoda", "hostina", "hotovost", "houba", "houf", "houpat", "houska", "hovor", "hradba", "hranice", "hravost", "hrazda", "hrbolek", "hrdina", "hrdlo", "hrdost", "hrnek", "hrobka", "hromada", "hrot", "hrouda", "hrozen", "hrstka", "hrubost", "hryzat", "hubenost", "hubnout", "hudba", "hukot", "humr", "husita", "hustota", "hvozd", "hybnost", "hydrant", "hygiena", "hymna", "hysterik", "idylka", "ihned", "ikona", "iluze", "imunita", "infekce", "inflace", "inkaso", "inovace", "inspekce", "internet", "invalida", "investor", "inzerce", "ironie", "jablko", "jachta", "jahoda", "jakmile", "jakost", "jalovec", "jantar", "jarmark", "jaro", "jasan", "jasno", "jatka", "javor", "jazyk", "jedinec", "jedle", "jednatel", "jehlan", "jekot", "jelen", "jelito", "jemnost", "jenom", "jepice", "jeseter", "jevit", "jezdec", "jezero", "jinak", "jindy", "jinoch", "jiskra", "jistota", "jitrnice", "jizva", "jmenovat", "jogurt", "jurta", "kabaret", "kabel", "kabinet", "kachna", "kadet", "kadidlo", "kahan", "kajak", "kajuta", "kakao", "kaktus", "kalamita", "kalhoty", "kalibr", "kalnost", "kamera", "kamkoliv", "kamna", "kanibal", "kanoe", "kantor", "kapalina", "kapela", "kapitola", "kapka", "kaple", "kapota", "kapr", "kapusta", "kapybara", "karamel", "karotka", "karton", "kasa", "katalog", "katedra", "kauce", "kauza", "kavalec", "kazajka", "kazeta", "kazivost", "kdekoliv", "kdesi", "kedluben", "kemp", "keramika", "kino", "klacek", "kladivo", "klam", "klapot", "klasika", "klaun", "klec", "klenba", "klepat", "klesnout", "klid", "klima", "klisna", "klobouk", "klokan", "klopa", "kloub", "klubovna", "klusat", "kluzkost", "kmen", "kmitat", "kmotr", "kniha", "knot", "koalice", "koberec", "kobka", "kobliha", "kobyla", "kocour", "kohout", "kojenec", "kokos", "koktejl", "kolaps", "koleda", "kolize", "kolo", "komando", "kometa", "komik", "komnata", "komora", "kompas", "komunita", "konat", "koncept", "kondice", "konec", "konfese", "kongres", "konina", "konkurs", "kontakt", "konzerva", "kopanec", "kopie", "kopnout", "koprovka", "korbel", "korektor", "kormidlo", "koroptev", "korpus", "koruna", "koryto", "korzet", "kosatec", "kostka", "kotel", "kotleta", "kotoul", "koukat", "koupelna", "kousek", "kouzlo", "kovboj", "koza", "kozoroh", "krabice", "krach", "krajina", "kralovat", "krasopis", "kravata", "kredit", "krejcar", "kresba", "kreveta", "kriket", "kritik", "krize", "krkavec", "krmelec", "krmivo", "krocan", "krok", "kronika", "kropit", "kroupa", "krovka", "krtek", "kruhadlo", "krupice", "krutost", "krvinka", "krychle", "krypta", "krystal", "kryt", "kudlanka", "kufr", "kujnost", "kukla", "kulajda", "kulich", "kulka", "kulomet", "kultura", "kuna", "kupodivu", "kurt", "kurzor", "kutil", "kvalita", "kvasinka", "kvestor", "kynolog", "kyselina", "kytara", "kytice", "kytka", "kytovec", "kyvadlo", "labrador", "lachtan", "ladnost", "laik", "lakomec", "lamela", "lampa", "lanovka", "lasice", "laso", "lastura", "latinka", "lavina", "lebka", "leckdy", "leden", "lednice", "ledovka", "ledvina", "legenda", "legie", "legrace", "lehce", "lehkost", "lehnout", "lektvar", "lenochod", "lentilka", "lepenka", "lepidlo", "letadlo", "letec", "letmo", "letokruh", "levhart", "levitace", "levobok", "libra", "lichotka", "lidojed", "lidskost", "lihovina", "lijavec", "lilek", "limetka", "linie", "linka", "linoleum", "listopad", "litina", "litovat", "lobista", "lodivod", "logika", "logoped", "lokalita", "loket", "lomcovat", "lopata", "lopuch", "lord", "losos", "lotr", "loudal", "louh", "louka", "louskat", "lovec", "lstivost", "lucerna", "lucifer", "lump", "lusk", "lustrace", "lvice", "lyra", "lyrika", "lysina", "madam", "madlo", "magistr", "mahagon", "majetek", "majitel", "majorita", "makak", "makovice", "makrela", "malba", "malina", "malovat", "malvice", "maminka", "mandle", "manko", "marnost", "masakr", "maskot", "masopust", "matice", "matrika", "maturita", "mazanec", "mazivo", "mazlit", "mazurka", "mdloba", "mechanik", "meditace", "medovina", "melasa", "meloun", "mentolka", "metla", "metoda", "metr", "mezera", "migrace", "mihnout", "mihule", "mikina", "mikrofon", "milenec", "milimetr", "milost", "mimika", "mincovna", "minibar", "minomet", "minulost", "miska", "mistr", "mixovat", "mladost", "mlha", "mlhovina", "mlok", "mlsat", "mluvit", "mnich", "mnohem", "mobil", "mocnost", "modelka", "modlitba", "mohyla", "mokro", "molekula", "momentka", "monarcha", "monokl", "monstrum", "montovat", "monzun", "mosaz", "moskyt", "most", "motivace", "motorka", "motyka", "moucha", "moudrost", "mozaika", "mozek", "mozol", "mramor", "mravenec", "mrkev", "mrtvola", "mrzet", "mrzutost", "mstitel", "mudrc", "muflon", "mulat", "mumie", "munice", "muset", "mutace", "muzeum", "muzikant", "myslivec", "mzda", "nabourat", "nachytat", "nadace", "nadbytek", "nadhoz", "nadobro", "nadpis", "nahlas", "nahnat", "nahodile", "nahradit", "naivita", "najednou", "najisto", "najmout", "naklonit", "nakonec", "nakrmit", "nalevo", "namazat", "namluvit", "nanometr", "naoko", "naopak", "naostro", "napadat", "napevno", "naplnit", "napnout", "naposled", "naprosto", "narodit", "naruby", "narychlo", "nasadit", "nasekat", "naslepo", "nastat", "natolik", "navenek", "navrch", "navzdory", "nazvat", "nebe", "nechat", "necky", "nedaleko", "nedbat", "neduh", "negace", "nehet", "nehoda", "nejen", "nejprve", "neklid", "nelibost", "nemilost", "nemoc", "neochota", "neonka", "nepokoj", "nerost", "nerv", "nesmysl", "nesoulad", "netvor", "neuron", "nevina", "nezvykle", "nicota", "nijak", "nikam", "nikdy", "nikl", "nikterak", "nitro", "nocleh", "nohavice", "nominace", "nora", "norek", "nositel", "nosnost", "nouze", "noviny", "novota", "nozdra", "nuda", "nudle", "nuget", "nutit", "nutnost", "nutrie", "nymfa", "obal", "obarvit", "obava", "obdiv", "obec", "obehnat", "obejmout", "obezita", "obhajoba", "obilnice", "objasnit", "objekt", "obklopit", "oblast", "oblek", "obliba", "obloha", "obluda", "obnos", "obohatit", "obojek", "obout", "obrazec", "obrna", "obruba", "obrys", "obsah", "obsluha", "obstarat", "obuv", "obvaz", "obvinit", "obvod", "obvykle", "obyvatel", "obzor", "ocas", "ocel", "ocenit", "ochladit", "ochota", "ochrana", "ocitnout", "odboj", "odbyt", "odchod", "odcizit", "odebrat", "odeslat", "odevzdat", "odezva", "odhadce", "odhodit", "odjet", "odjinud", "odkaz", "odkoupit", "odliv", "odluka", "odmlka", "odolnost", "odpad", "odpis", "odplout", "odpor", "odpustit", "odpykat", "odrazka", "odsoudit", "odstup", "odsun", "odtok", "odtud", "odvaha", "odveta", "odvolat", "odvracet", "odznak", "ofina", "ofsajd", "ohlas", "ohnisko", "ohrada", "ohrozit", "ohryzek", "okap", "okenice", "oklika", "okno", "okouzlit", "okovy", "okrasa", "okres", "okrsek", "okruh", "okupant", "okurka", "okusit", "olejnina", "olizovat", "omak", "omeleta", "omezit", "omladina", "omlouvat", "omluva", "omyl", "onehdy", "opakovat", "opasek", "operace", "opice", "opilost", "opisovat", "opora", "opozice", "opravdu", "oproti", "orbital", "orchestr", "orgie", "orlice", "orloj", "ortel", "osada", "oschnout", "osika", "osivo", "oslava", "oslepit", "oslnit", "oslovit", "osnova", "osoba", "osolit", "ospalec", "osten", "ostraha", "ostuda", "ostych", "osvojit", "oteplit", "otisk", "otop", "otrhat", "otrlost", "otrok", "otruby", "otvor", "ovanout", "ovar", "oves", "ovlivnit", "ovoce", "oxid", "ozdoba", "pachatel", "pacient", "padouch", "pahorek", "pakt", "palanda", "palec", "palivo", "paluba", "pamflet", "pamlsek", "panenka", "panika", "panna", "panovat", "panstvo", "pantofle", "paprika", "parketa", "parodie", "parta", "paruka", "paryba", "paseka", "pasivita", "pastelka", "patent", "patrona", "pavouk", "pazneht", "pazourek", "pecka", "pedagog", "pejsek", "peklo", "peloton", "penalta", "pendrek", "penze", "periskop", "pero", "pestrost", "petarda", "petice", "petrolej", "pevnina", "pexeso", "pianista", "piha", "pijavice", "pikle", "piknik", "pilina", "pilnost", "pilulka", "pinzeta", "pipeta", "pisatel", "pistole", "pitevna", "pivnice", "pivovar", "placenta", "plakat", "plamen", "planeta", "plastika", "platit", "plavidlo", "plaz", "plech", "plemeno", "plenta", "ples", "pletivo", "plevel", "plivat", "plnit", "plno", "plocha", "plodina", "plomba", "plout", "pluk", "plyn", "pobavit", "pobyt", "pochod", "pocit", "poctivec", "podat", "podcenit", "podepsat", "podhled", "podivit", "podklad", "podmanit", "podnik", "podoba", "podpora", "podraz", "podstata", "podvod", "podzim", "poezie", "pohanka", "pohnutka", "pohovor", "pohroma", "pohyb", "pointa", "pojistka", "pojmout", "pokazit", "pokles", "pokoj", "pokrok", "pokuta", "pokyn", "poledne", "polibek", "polknout", "poloha", "polynom", "pomalu", "pominout", "pomlka", "pomoc", "pomsta", "pomyslet", "ponechat", "ponorka", "ponurost", "popadat", "popel", "popisek", "poplach", "poprosit", "popsat", "popud", "poradce", "porce", "porod", "porucha", "poryv", "posadit", "posed", "posila", "poskok", "poslanec", "posoudit", "pospolu", "postava", "posudek", "posyp", "potah", "potkan", "potlesk", "potomek", "potrava", "potupa", "potvora", "poukaz", "pouto", "pouzdro", "povaha", "povidla", "povlak", "povoz", "povrch", "povstat", "povyk", "povzdech", "pozdrav", "pozemek", "poznatek", "pozor", "pozvat", "pracovat", "prahory", "praktika", "prales", "praotec", "praporek", "prase", "pravda", "princip", "prkno", "probudit", "procento", "prodej", "profese", "prohra", "projekt", "prolomit", "promile", "pronikat", "propad", "prorok", "prosba", "proton", "proutek", "provaz", "prskavka", "prsten", "prudkost", "prut", "prvek", "prvohory", "psanec", "psovod", "pstruh", "ptactvo", "puberta", "puch", "pudl", "pukavec", "puklina", "pukrle", "pult", "pumpa", "punc", "pupen", "pusa", "pusinka", "pustina", "putovat", "putyka", "pyramida", "pysk", "pytel", "racek", "rachot", "radiace", "radnice", "radon", "raft", "ragby", "raketa", "rakovina", "rameno", "rampouch", "rande", "rarach", "rarita", "rasovna", "rastr", "ratolest", "razance", "razidlo", "reagovat", "reakce", "recept", "redaktor", "referent", "reflex", "rejnok", "reklama", "rekord", "rekrut", "rektor", "reputace", "revize", "revma", "revolver", "rezerva", "riskovat", "riziko", "robotika", "rodokmen", "rohovka", "rokle", "rokoko", "romaneto", "ropovod", "ropucha", "rorejs", "rosol", "rostlina", "rotmistr", "rotoped", "rotunda", "roubenka", "roucho", "roup", "roura", "rovina", "rovnice", "rozbor", "rozchod", "rozdat", "rozeznat", "rozhodce", "rozinka", "rozjezd", "rozkaz", "rozloha", "rozmar", "rozpad", "rozruch", "rozsah", "roztok", "rozum", "rozvod", "rubrika", "ruchadlo", "rukavice", "rukopis", "ryba", "rybolov", "rychlost", "rydlo", "rypadlo", "rytina", "ryzost", "sadista", "sahat", "sako", "samec", "samizdat", "samota", "sanitka", "sardinka", "sasanka", "satelit", "sazba", "sazenice", "sbor", "schovat", "sebranka", "secese", "sedadlo", "sediment", "sedlo", "sehnat", "sejmout", "sekera", "sekta", "sekunda", "sekvoje", "semeno", "seno", "servis", "sesadit", "seshora", "seskok", "seslat", "sestra", "sesuv", "sesypat", "setba", "setina", "setkat", "setnout", "setrvat", "sever", "seznam", "shoda", "shrnout", "sifon", "silnice", "sirka", "sirotek", "sirup", "situace", "skafandr", "skalisko", "skanzen", "skaut", "skeptik", "skica", "skladba", "sklenice", "sklo", "skluz", "skoba", "skokan", "skoro", "skripta", "skrz", "skupina", "skvost", "skvrna", "slabika", "sladidlo", "slanina", "slast", "slavnost", "sledovat", "slepec", "sleva", "slezina", "slib", "slina", "sliznice", "slon", "sloupek", "slovo", "sluch", "sluha", "slunce", "slupka", "slza", "smaragd", "smetana", "smilstvo", "smlouva", "smog", "smrad", "smrk", "smrtka", "smutek", "smysl", "snad", "snaha", "snob", "sobota", "socha", "sodovka", "sokol", "sopka", "sotva", "souboj", "soucit", "soudce", "souhlas", "soulad", "soumrak", "souprava", "soused", "soutok", "souviset", "spalovna", "spasitel", "spis", "splav", "spodek", "spojenec", "spolu", "sponzor", "spornost", "spousta", "sprcha", "spustit", "sranda", "sraz", "srdce", "srna", "srnec", "srovnat", "srpen", "srst", "srub", "stanice", "starosta", "statika", "stavba", "stehno", "stezka", "stodola", "stolek", "stopa", "storno", "stoupat", "strach", "stres", "strhnout", "strom", "struna", "studna", "stupnice", "stvol", "styk", "subjekt", "subtropy", "suchar", "sudost", "sukno", "sundat", "sunout", "surikata", "surovina", "svah", "svalstvo", "svetr", "svatba", "svazek", "svisle", "svitek", "svoboda", "svodidlo", "svorka", "svrab", "sykavka", "sykot", "synek", "synovec", "sypat", "sypkost", "syrovost", "sysel", "sytost", "tabletka", "tabule", "tahoun", "tajemno", "tajfun", "tajga", "tajit", "tajnost", "taktika", "tamhle", "tampon", "tancovat", "tanec", "tanker", "tapeta", "tavenina", "tazatel", "technika", "tehdy", "tekutina", "telefon", "temnota", "tendence", "tenista", "tenor", "teplota", "tepna", "teprve", "terapie", "termoska", "textil", "ticho", "tiskopis", "titulek", "tkadlec", "tkanina", "tlapka", "tleskat", "tlukot", "tlupa", "tmel", "toaleta", "topinka", "topol", "torzo", "touha", "toulec", "tradice", "traktor", "tramp", "trasa", "traverza", "trefit", "trest", "trezor", "trhavina", "trhlina", "trochu", "trojice", "troska", "trouba", "trpce", "trpitel", "trpkost", "trubec", "truchlit", "truhlice", "trus", "trvat", "tudy", "tuhnout", "tuhost", "tundra", "turista", "turnaj", "tuzemsko", "tvaroh", "tvorba", "tvrdost", "tvrz", "tygr", "tykev", "ubohost", "uboze", "ubrat", "ubrousek", "ubrus", "ubytovna", "ucho", "uctivost", "udivit", "uhradit", "ujednat", "ujistit", "ujmout", "ukazatel", "uklidnit", "uklonit", "ukotvit", "ukrojit", "ulice", "ulita", "ulovit", "umyvadlo", "unavit", "uniforma", "uniknout", "upadnout", "uplatnit", "uplynout", "upoutat", "upravit", "uran", "urazit", "usednout", "usilovat", "usmrtit", "usnadnit", "usnout", "usoudit", "ustlat", "ustrnout", "utahovat", "utkat", "utlumit", "utonout", "utopenec", "utrousit", "uvalit", "uvolnit", "uvozovka", "uzdravit", "uzel", "uzenina", "uzlina", "uznat", "vagon", "valcha", "valoun", "vana", "vandal", "vanilka", "varan", "varhany", "varovat", "vcelku", "vchod", "vdova", "vedro", "vegetace", "vejce", "velbloud", "veletrh", "velitel", "velmoc", "velryba", "venkov", "veranda", "verze", "veselka", "veskrze", "vesnice", "vespodu", "vesta", "veterina", "veverka", "vibrace", "vichr", "videohra", "vidina", "vidle", "vila", "vinice", "viset", "vitalita", "vize", "vizitka", "vjezd", "vklad", "vkus", "vlajka", "vlak", "vlasec", "vlevo", "vlhkost", "vliv", "vlnovka", "vloupat", "vnucovat", "vnuk", "voda", "vodivost", "vodoznak", "vodstvo", "vojensky", "vojna", "vojsko", "volant", "volba", "volit", "volno", "voskovka", "vozidlo", "vozovna", "vpravo", "vrabec", "vracet", "vrah", "vrata", "vrba", "vrcholek", "vrhat", "vrstva", "vrtule", "vsadit", "vstoupit", "vstup", "vtip", "vybavit", "vybrat", "vychovat", "vydat", "vydra", "vyfotit", "vyhledat", "vyhnout", "vyhodit", "vyhradit", "vyhubit", "vyjasnit", "vyjet", "vyjmout", "vyklopit", "vykonat", "vylekat", "vymazat", "vymezit", "vymizet", "vymyslet", "vynechat", "vynikat", "vynutit", "vypadat", "vyplatit", "vypravit", "vypustit", "vyrazit", "vyrovnat", "vyrvat", "vyslovit", "vysoko", "vystavit", "vysunout", "vysypat", "vytasit", "vytesat", "vytratit", "vyvinout", "vyvolat", "vyvrhel", "vyzdobit", "vyznat", "vzadu", "vzbudit", "vzchopit", "vzdor", "vzduch", "vzdychat", "vzestup", "vzhledem", "vzkaz", "vzlykat", "vznik", "vzorek", "vzpoura", "vztah", "vztek", "xylofon", "zabrat", "zabydlet", "zachovat", "zadarmo", "zadusit", "zafoukat", "zahltit", "zahodit", "zahrada", "zahynout", "zajatec", "zajet", "zajistit", "zaklepat", "zakoupit", "zalepit", "zamezit", "zamotat", "zamyslet", "zanechat", "zanikat", "zaplatit", "zapojit", "zapsat", "zarazit", "zastavit", "zasunout", "zatajit", "zatemnit", "zatknout", "zaujmout", "zavalit", "zavelet", "zavinit", "zavolat", "zavrtat", "zazvonit", "zbavit", "zbrusu", "zbudovat", "zbytek", "zdaleka", "zdarma", "zdatnost", "zdivo", "zdobit", "zdroj", "zdvih", "zdymadlo", "zelenina", "zeman", "zemina", "zeptat", "zezadu", "zezdola", "zhatit", "zhltnout", "zhluboka", "zhotovit", "zhruba", "zima", "zimnice", "zjemnit", "zklamat", "zkoumat", "zkratka", "zkumavka", "zlato", "zlehka", "zloba", "zlom", "zlost", "zlozvyk", "zmapovat", "zmar", "zmatek", "zmije", "zmizet", "zmocnit", "zmodrat", "zmrzlina", "zmutovat", "znak", "znalost", "znamenat", "znovu", "zobrazit", "zotavit", "zoubek", "zoufale", "zplodit", "zpomalit", "zprava", "zprostit", "zprudka", "zprvu", "zrada", "zranit", "zrcadlo", "zrnitost", "zrno", "zrovna", "zrychlit", "zrzavost", "zticha", "ztratit", "zubovina", "zubr", "zvednout", "zvenku", "zvesela", "zvon", "zvrat", "zvukovod", "zvyk" };
 
+        /// <summary>
+        /// Czech Constructor
+        /// </summary>
         public Czech() : base(words)
         {
         }
     }
 
+    /// <summary>
+    /// Italian Words
+    /// </summary>
     public class Italian : Wordlist
     {
+        /// <summary>
+        /// Words
+        /// </summary>
         private static readonly string[] words = { "abaco", "abbaglio", "abbinato", "abete", "abisso", "abolire", "abrasivo", "abrogato", "accadere", "accenno", "accusato", "acetone", "achille", "acido", "acqua", "acre", "acrilico", "acrobata", "acuto", "adagio", "addebito", "addome", "adeguato", "aderire", "adipe", "adottare", "adulare", "affabile", "affetto", "affisso", "affranto", "aforisma", "afoso", "africano", "agave", "agente", "agevole", "aggancio", "agire", "agitare", "agonismo", "agricolo", "agrumeto", "aguzzo", "alabarda", "alato", "albatro", "alberato", "albo", "albume", "alce", "alcolico", "alettone", "alfa", "algebra", "aliante", "alibi", "alimento", "allagato", "allegro", "allievo", "allodola", "allusivo", "almeno", "alogeno", "alpaca", "alpestre", "altalena", "alterno", "alticcio", "altrove", "alunno", "alveolo", "alzare", "amalgama", "amanita", "amarena", "ambito", "ambrato", "ameba", "america", "ametista", "amico", "ammasso", "ammenda", "ammirare", "ammonito", "amore", "ampio", "ampliare", "amuleto", "anacardo", "anagrafe", "analista", "anarchia", "anatra", "anca", "ancella", "ancora", "andare", "andrea", "anello", "angelo", "angolare", "angusto", "anima", "annegare", "annidato", "anno", "annuncio", "anonimo", "anticipo", "anzi", "apatico", "apertura", "apode", "apparire", "appetito", "appoggio", "approdo", "appunto", "aprile", "arabica", "arachide", "aragosta", "araldica", "arancio", "aratura", "arazzo", "arbitro", "archivio", "ardito", "arenile", "argento", "argine", "arguto", "aria", "armonia", "arnese", "arredato", "arringa", "arrosto", "arsenico", "arso", "artefice", "arzillo", "asciutto", "ascolto", "asepsi", "asettico", "asfalto", "asino", "asola", "aspirato", "aspro", "assaggio", "asse", "assoluto", "assurdo", "asta", "astenuto", "astice", "astratto", "atavico", "ateismo", "atomico", "atono", "attesa", "attivare", "attorno", "attrito", "attuale", "ausilio", "austria", "autista", "autonomo", "autunno", "avanzato", "avere", "avvenire", "avviso", "avvolgere", "azione", "azoto", "azzimo", "azzurro", "babele", "baccano", "bacino", "baco", "badessa", "badilata", "bagnato", "baita", "balcone", "baldo", "balena", "ballata", "balzano", "bambino", "bandire", "baraonda", "barbaro", "barca", "baritono", "barlume", "barocco", "basilico", "basso", "batosta", "battuto", "baule", "bava", "bavosa", "becco", "beffa", "belgio", "belva", "benda", "benevole", "benigno", "benzina", "bere", "berlina", "beta", "bibita", "bici", "bidone", "bifido", "biga", "bilancia", "bimbo", "binocolo", "biologo", "bipede", "bipolare", "birbante", "birra", "biscotto", "bisesto", "bisnonno", "bisonte", "bisturi", "bizzarro", "blando", "blatta", "bollito", "bonifico", "bordo", "bosco", "botanico", "bottino", "bozzolo", "braccio", "bradipo", "brama", "branca", "bravura", "bretella", "brevetto", "brezza", "briglia", "brillante", "brindare", "broccolo", "brodo", "bronzina", "brullo", "bruno", "bubbone", "buca", "budino", "buffone", "buio", "bulbo", "buono", "burlone", "burrasca", "bussola", "busta", "cadetto", "caduco", "calamaro", "calcolo", "calesse", "calibro", "calmo", "caloria", "cambusa", "camerata", "camicia", "cammino", "camola", "campale", "canapa", "candela", "cane", "canino", "canotto", "cantina", "capace", "capello", "capitolo", "capogiro", "cappero", "capra", "capsula", "carapace", "carcassa", "cardo", "carisma", "carovana", "carretto", "cartolina", "casaccio", "cascata", "caserma", "caso", "cassone", "castello", "casuale", "catasta", "catena", "catrame", "cauto", "cavillo", "cedibile", "cedrata", "cefalo", "celebre", "cellulare", "cena", "cenone", "centesimo", "ceramica", "cercare", "certo", "cerume", "cervello", "cesoia", "cespo", "ceto", "chela", "chiaro", "chicca", "chiedere", "chimera", "china", "chirurgo", "chitarra", "ciao", "ciclismo", "cifrare", "cigno", "cilindro", "ciottolo", "circa", "cirrosi", "citrico", "cittadino", "ciuffo", "civetta", "civile", "classico", "clinica", "cloro", "cocco", "codardo", "codice", "coerente", "cognome", "collare", "colmato", "colore", "colposo", "coltivato", "colza", "coma", "cometa", "commando", "comodo", "computer", "comune", "conciso", "condurre", "conferma", "congelare", "coniuge", "connesso", "conoscere", "consumo", "continuo", "convegno", "coperto", "copione", "coppia", "copricapo", "corazza", "cordata", "coricato", "cornice", "corolla", "corpo", "corredo", "corsia", "cortese", "cosmico", "costante", "cottura", "covato", "cratere", "cravatta", "creato", "credere", "cremoso", "crescita", "creta", "criceto", "crinale", "crisi", "critico", "croce", "cronaca", "crostata", "cruciale", "crusca", "cucire", "cuculo", "cugino", "cullato", "cupola", "curatore", "cursore", "curvo", "cuscino", "custode", "dado", "daino", "dalmata", "damerino", "daniela", "dannoso", "danzare", "datato", "davanti", "davvero", "debutto", "decennio", "deciso", "declino", "decollo", "decreto", "dedicato", "definito", "deforme", "degno", "delegare", "delfino", "delirio", "delta", "demenza", "denotato", "dentro", "deposito", "derapata", "derivare", "deroga", "descritto", "deserto", "desiderio", "desumere", "detersivo", "devoto", "diametro", "dicembre", "diedro", "difeso", "diffuso", "digerire", "digitale", "diluvio", "dinamico", "dinnanzi", "dipinto", "diploma", "dipolo", "diradare", "dire", "dirotto", "dirupo", "disagio", "discreto", "disfare", "disgelo", "disposto", "distanza", "disumano", "dito", "divano", "divelto", "dividere", "divorato", "doblone", "docente", "doganale", "dogma", "dolce", "domato", "domenica", "dominare", "dondolo", "dono", "dormire", "dote", "dottore", "dovuto", "dozzina", "drago", "druido", "dubbio", "dubitare", "ducale", "duna", "duomo", "duplice", "duraturo", "ebano", "eccesso", "ecco", "eclissi", "economia", "edera", "edicola", "edile", "editoria", "educare", "egemonia", "egli", "egoismo", "egregio", "elaborato", "elargire", "elegante", "elencato", "eletto", "elevare", "elfico", "elica", "elmo", "elsa", "eluso", "emanato", "emblema", "emesso", "emiro", "emotivo", "emozione", "empirico", "emulo", "endemico", "enduro", "energia", "enfasi", "enoteca", "entrare", "enzima", "epatite", "epilogo", "episodio", "epocale", "eppure", "equatore", "erario", "erba", "erboso", "erede", "eremita", "erigere", "ermetico", "eroe", "erosivo", "errante", "esagono", "esame", "esanime", "esaudire", "esca", "esempio", "esercito", "esibito", "esigente", "esistere", "esito", "esofago", "esortato", "esoso", "espanso", "espresso", "essenza", "esso", "esteso", "estimare", "estonia", "estroso", "esultare", "etilico", "etnico", "etrusco", "etto", "euclideo", "europa", "evaso", "evidenza", "evitato", "evoluto", "evviva", "fabbrica", "faccenda", "fachiro", "falco", "famiglia", "fanale", "fanfara", "fango", "fantasma", "fare", "farfalla", "farinoso", "farmaco", "fascia", "fastoso", "fasullo", "faticare", "fato", "favoloso", "febbre", "fecola", "fede", "fegato", "felpa", "feltro", "femmina", "fendere", "fenomeno", "fermento", "ferro", "fertile", "fessura", "festivo", "fetta", "feudo", "fiaba", "fiducia", "fifa", "figurato", "filo", "finanza", "finestra", "finire", "fiore", "fiscale", "fisico", "fiume", "flacone", "flamenco", "flebo", "flemma", "florido", "fluente", "fluoro", "fobico", "focaccia", "focoso", "foderato", "foglio", "folata", "folclore", "folgore", "fondente", "fonetico", "fonia", "fontana", "forbito", "forchetta", "foresta", "formica", "fornaio", "foro", "fortezza", "forzare", "fosfato", "fosso", "fracasso", "frana", "frassino", "fratello", "freccetta", "frenata", "fresco", "frigo", "frollino", "fronde", "frugale", "frutta", "fucilata", "fucsia", "fuggente", "fulmine", "fulvo", "fumante", "fumetto", "fumoso", "fune", "funzione", "fuoco", "furbo", "furgone", "furore", "fuso", "futile", "gabbiano", "gaffe", "galateo", "gallina", "galoppo", "gambero", "gamma", "garanzia", "garbo", "garofano", "garzone", "gasdotto", "gasolio", "gastrico", "gatto", "gaudio", "gazebo", "gazzella", "geco", "gelatina", "gelso", "gemello", "gemmato", "gene", "genitore", "gennaio", "genotipo", "gergo", "ghepardo", "ghiaccio", "ghisa", "giallo", "gilda", "ginepro", "giocare", "gioiello", "giorno", "giove", "girato", "girone", "gittata", "giudizio", "giurato", "giusto", "globulo", "glutine", "gnomo", "gobba", "golf", "gomito", "gommone", "gonfio", "gonna", "governo", "gracile", "grado", "grafico", "grammo", "grande", "grattare", "gravoso", "grazia", "greca", "gregge", "grifone", "grigio", "grinza", "grotta", "gruppo", "guadagno", "guaio", "guanto", "guardare", "gufo", "guidare", "ibernato", "icona", "identico", "idillio", "idolo", "idra", "idrico", "idrogeno", "igiene", "ignaro", "ignorato", "ilare", "illeso", "illogico", "illudere", "imballo", "imbevuto", "imbocco", "imbuto", "immane", "immerso", "immolato", "impacco", "impeto", "impiego", "importo", "impronta", "inalare", "inarcare", "inattivo", "incanto", "incendio", "inchino", "incisivo", "incluso", "incontro", "incrocio", "incubo", "indagine", "india", "indole", "inedito", "infatti", "infilare", "inflitto", "ingaggio", "ingegno", "inglese", "ingordo", "ingrosso", "innesco", "inodore", "inoltrare", "inondato", "insano", "insetto", "insieme", "insonnia", "insulina", "intasato", "intero", "intonaco", "intuito", "inumidire", "invalido", "invece", "invito", "iperbole", "ipnotico", "ipotesi", "ippica", "iride", "irlanda", "ironico", "irrigato", "irrorare", "isolato", "isotopo", "isterico", "istituto", "istrice", "italia", "iterare", "labbro", "labirinto", "lacca", "lacerato", "lacrima", "lacuna", "laddove", "lago", "lampo", "lancetta", "lanterna", "lardoso", "larga", "laringe", "lastra", "latenza", "latino", "lattuga", "lavagna", "lavoro", "legale", "leggero", "lembo", "lentezza", "lenza", "leone", "lepre", "lesivo", "lessato", "lesto", "letterale", "leva", "levigato", "libero", "lido", "lievito", "lilla", "limatura", "limitare", "limpido", "lineare", "lingua", "liquido", "lira", "lirica", "lisca", "lite", "litigio", "livrea", "locanda", "lode", "logica", "lombare", "londra", "longevo", "loquace", "lorenzo", "loto", "lotteria", "luce", "lucidato", "lumaca", "luminoso", "lungo", "lupo", "luppolo", "lusinga", "lusso", "lutto", "macabro", "macchina", "macero", "macinato", "madama", "magico", "maglia", "magnete", "magro", "maiolica", "malafede", "malgrado", "malinteso", "malsano", "malto", "malumore", "mana", "mancia", "mandorla", "mangiare", "manifesto", "mannaro", "manovra", "mansarda", "mantide", "manubrio", "mappa", "maratona", "marcire", "maretta", "marmo", "marsupio", "maschera", "massaia", "mastino", "materasso", "matricola", "mattone", "maturo", "mazurca", "meandro", "meccanico", "mecenate", "medesimo", "meditare", "mega", "melassa", "melis", "melodia", "meninge", "meno", "mensola", "mercurio", "merenda", "merlo", "meschino", "mese", "messere", "mestolo", "metallo", "metodo", "mettere", "miagolare", "mica", "micelio", "michele", "microbo", "midollo", "miele", "migliore", "milano", "milite", "mimosa", "minerale", "mini", "minore", "mirino", "mirtillo", "miscela", "missiva", "misto", "misurare", "mitezza", "mitigare", "mitra", "mittente", "mnemonico", "modello", "modifica", "modulo", "mogano", "mogio", "mole", "molosso", "monastero", "monco", "mondina", "monetario", "monile", "monotono", "monsone", "montato", "monviso", "mora", "mordere", "morsicato", "mostro", "motivato", "motosega", "motto", "movenza", "movimento", "mozzo", "mucca", "mucosa", "muffa", "mughetto", "mugnaio", "mulatto", "mulinello", "multiplo", "mummia", "munto", "muovere", "murale", "musa", "muscolo", "musica", "mutevole", "muto", "nababbo", "nafta", "nanometro", "narciso", "narice", "narrato", "nascere", "nastrare", "naturale", "nautica", "naviglio", "nebulosa", "necrosi", "negativo", "negozio", "nemmeno", "neofita", "neretto", "nervo", "nessuno", "nettuno", "neutrale", "neve", "nevrotico", "nicchia", "ninfa", "nitido", "nobile", "nocivo", "nodo", "nome", "nomina", "nordico", "normale", "norvegese", "nostrano", "notare", "notizia", "notturno", "novella", "nucleo", "nulla", "numero", "nuovo", "nutrire", "nuvola", "nuziale", "oasi", "obbedire", "obbligo", "obelisco", "oblio", "obolo", "obsoleto", "occasione", "occhio", "occidente", "occorrere", "occultare", "ocra", "oculato", "odierno", "odorare", "offerta", "offrire", "offuscato", "oggetto", "oggi", "ognuno", "olandese", "olfatto", "oliato", "oliva", "ologramma", "oltre", "omaggio", "ombelico", "ombra", "omega", "omissione", "ondoso", "onere", "onice", "onnivoro", "onorevole", "onta", "operato", "opinione", "opposto", "oracolo", "orafo", "ordine", "orecchino", "orefice", "orfano", "organico", "origine", "orizzonte", "orma", "ormeggio", "ornativo", "orologio", "orrendo", "orribile", "ortensia", "ortica", "orzata", "orzo", "osare", "oscurare", "osmosi", "ospedale", "ospite", "ossa", "ossidare", "ostacolo", "oste", "otite", "otre", "ottagono", "ottimo", "ottobre", "ovale", "ovest", "ovino", "oviparo", "ovocito", "ovunque", "ovviare", "ozio", "pacchetto", "pace", "pacifico", "padella", "padrone", "paese", "paga", "pagina", "palazzina", "palesare", "pallido", "palo", "palude", "pandoro", "pannello", "paolo", "paonazzo", "paprica", "parabola", "parcella", "parere", "pargolo", "pari", "parlato", "parola", "partire", "parvenza", "parziale", "passivo", "pasticca", "patacca", "patologia", "pattume", "pavone", "peccato", "pedalare", "pedonale", "peggio", "peloso", "penare", "pendice", "penisola", "pennuto", "penombra", "pensare", "pentola", "pepe", "pepita", "perbene", "percorso", "perdonato", "perforare", "pergamena", "periodo", "permesso", "perno", "perplesso", "persuaso", "pertugio", "pervaso", "pesatore", "pesista", "peso", "pestifero", "petalo", "pettine", "petulante", "pezzo", "piacere", "pianta", "piattino", "piccino", "picozza", "piega", "pietra", "piffero", "pigiama", "pigolio", "pigro", "pila", "pilifero", "pillola", "pilota", "pimpante", "pineta", "pinna", "pinolo", "pioggia", "piombo", "piramide", "piretico", "pirite", "pirolisi", "pitone", "pizzico", "placebo", "planare", "plasma", "platano", "plenario", "pochezza", "poderoso", "podismo", "poesia", "poggiare", "polenta", "poligono", "pollice", "polmonite", "polpetta", "polso", "poltrona", "polvere", "pomice", "pomodoro", "ponte", "popoloso", "porfido", "poroso", "porpora", "porre", "portata", "posa", "positivo", "possesso", "postulato", "potassio", "potere", "pranzo", "prassi", "pratica", "precluso", "predica", "prefisso", "pregiato", "prelievo", "premere", "prenotare", "preparato", "presenza", "pretesto", "prevalso", "prima", "principe", "privato", "problema", "procura", "produrre", "profumo", "progetto", "prolunga", "promessa", "pronome", "proposta", "proroga", "proteso", "prova", "prudente", "prugna", "prurito", "psiche", "pubblico", "pudica", "pugilato", "pugno", "pulce", "pulito", "pulsante", "puntare", "pupazzo", "pupilla", "puro", "quadro", "qualcosa", "quasi", "querela", "quota", "raccolto", "raddoppio", "radicale", "radunato", "raffica", "ragazzo", "ragione", "ragno", "ramarro", "ramingo", "ramo", "randagio", "rantolare", "rapato", "rapina", "rappreso", "rasatura", "raschiato", "rasente", "rassegna", "rastrello", "rata", "ravveduto", "reale", "recepire", "recinto", "recluta", "recondito", "recupero", "reddito", "redimere", "regalato", "registro", "regola", "regresso", "relazione", "remare", "remoto", "renna", "replica", "reprimere", "reputare", "resa", "residente", "responso", "restauro", "rete", "retina", "retorica", "rettifica", "revocato", "riassunto", "ribadire", "ribelle", "ribrezzo", "ricarica", "ricco", "ricevere", "riciclato", "ricordo", "ricreduto", "ridicolo", "ridurre", "rifasare", "riflesso", "riforma", "rifugio", "rigare", "rigettato", "righello", "rilassato", "rilevato", "rimanere", "rimbalzo", "rimedio", "rimorchio", "rinascita", "rincaro", "rinforzo", "rinnovo", "rinomato", "rinsavito", "rintocco", "rinuncia", "rinvenire", "riparato", "ripetuto", "ripieno", "riportare", "ripresa", "ripulire", "risata", "rischio", "riserva", "risibile", "riso", "rispetto", "ristoro", "risultato", "risvolto", "ritardo", "ritegno", "ritmico", "ritrovo", "riunione", "riva", "riverso", "rivincita", "rivolto", "rizoma", "roba", "robotico", "robusto", "roccia", "roco", "rodaggio", "rodere", "roditore", "rogito", "rollio", "romantico", "rompere", "ronzio", "rosolare", "rospo", "rotante", "rotondo", "rotula", "rovescio", "rubizzo", "rubrica", "ruga", "rullino", "rumine", "rumoroso", "ruolo", "rupe", "russare", "rustico", "sabato", "sabbiare", "sabotato", "sagoma", "salasso", "saldatura", "salgemma", "salivare", "salmone", "salone", "saltare", "saluto", "salvo", "sapere", "sapido", "saporito", "saraceno", "sarcasmo", "sarto", "sassoso", "satellite", "satira", "satollo", "saturno", "savana", "savio", "saziato", "sbadiglio", "sbalzo", "sbancato", "sbarra", "sbattere", "sbavare", "sbendare", "sbirciare", "sbloccato", "sbocciato", "sbrinare", "sbruffone", "sbuffare", "scabroso", "scadenza", "scala", "scambiare", "scandalo", "scapola", "scarso", "scatenare", "scavato", "scelto", "scenico", "scettro", "scheda", "schiena", "sciarpa", "scienza", "scindere", "scippo", "sciroppo", "scivolo", "sclerare", "scodella", "scolpito", "scomparto", "sconforto", "scoprire", "scorta", "scossone", "scozzese", "scriba", "scrollare", "scrutinio", "scuderia", "scultore", "scuola", "scuro", "scusare", "sdebitare", "sdoganare", "seccatura", "secondo", "sedano", "seggiola", "segnalato", "segregato", "seguito", "selciato", "selettivo", "sella", "selvaggio", "semaforo", "sembrare", "seme", "seminato", "sempre", "senso", "sentire", "sepolto", "sequenza", "serata", "serbato", "sereno", "serio", "serpente", "serraglio", "servire", "sestina", "setola", "settimana", "sfacelo", "sfaldare", "sfamato", "sfarzoso", "sfaticato", "sfera", "sfida", "sfilato", "sfinge", "sfocato", "sfoderare", "sfogo", "sfoltire", "sforzato", "sfratto", "sfruttato", "sfuggito", "sfumare", "sfuso", "sgabello", "sgarbato", "sgonfiare", "sgorbio", "sgrassato", "sguardo", "sibilo", "siccome", "sierra", "sigla", "signore", "silenzio", "sillaba", "simbolo", "simpatico", "simulato", "sinfonia", "singolo", "sinistro", "sino", "sintesi", "sinusoide", "sipario", "sisma", "sistole", "situato", "slitta", "slogatura", "sloveno", "smarrito", "smemorato", "smentito", "smeraldo", "smilzo", "smontare", "smottato", "smussato", "snellire", "snervato", "snodo", "sobbalzo", "sobrio", "soccorso", "sociale", "sodale", "soffitto", "sogno", "soldato", "solenne", "solido", "sollazzo", "solo", "solubile", "solvente", "somatico", "somma", "sonda", "sonetto", "sonnifero", "sopire", "soppeso", "sopra", "sorgere", "sorpasso", "sorriso", "sorso", "sorteggio", "sorvolato", "sospiro", "sosta", "sottile", "spada", "spalla", "spargere", "spatola", "spavento", "spazzola", "specie", "spedire", "spegnere", "spelatura", "speranza", "spessore", "spettrale", "spezzato", "spia", "spigoloso", "spillato", "spinoso", "spirale", "splendido", "sportivo", "sposo", "spranga", "sprecare", "spronato", "spruzzo", "spuntino", "squillo", "sradicare", "srotolato", "stabile", "stacco", "staffa", "stagnare", "stampato", "stantio", "starnuto", "stasera", "statuto", "stelo", "steppa", "sterzo", "stiletto", "stima", "stirpe", "stivale", "stizzoso", "stonato", "storico", "strappo", "stregato", "stridulo", "strozzare", "strutto", "stuccare", "stufo", "stupendo", "subentro", "succoso", "sudore", "suggerito", "sugo", "sultano", "suonare", "superbo", "supporto", "surgelato", "surrogato", "sussurro", "sutura", "svagare", "svedese", "sveglio", "svelare", "svenuto", "svezia", "sviluppo", "svista", "svizzera", "svolta", "svuotare", "tabacco", "tabulato", "tacciare", "taciturno", "tale", "talismano", "tampone", "tannino", "tara", "tardivo", "targato", "tariffa", "tarpare", "tartaruga", "tasto", "tattico", "taverna", "tavolata", "tazza", "teca", "tecnico", "telefono", "temerario", "tempo", "temuto", "tendone", "tenero", "tensione", "tentacolo", "teorema", "terme", "terrazzo", "terzetto", "tesi", "tesserato", "testato", "tetro", "tettoia", "tifare", "tigella", "timbro", "tinto", "tipico", "tipografo", "tiraggio", "tiro", "titanio", "titolo", "titubante", "tizio", "tizzone", "toccare", "tollerare", "tolto", "tombola", "tomo", "tonfo", "tonsilla", "topazio", "topologia", "toppa", "torba", "tornare", "torrone", "tortora", "toscano", "tossire", "tostatura", "totano", "trabocco", "trachea", "trafila", "tragedia", "tralcio", "tramonto", "transito", "trapano", "trarre", "trasloco", "trattato", "trave", "treccia", "tremolio", "trespolo", "tributo", "tricheco", "trifoglio", "trillo", "trincea", "trio", "tristezza", "triturato", "trivella", "tromba", "trono", "troppo", "trottola", "trovare", "truccato", "tubatura", "tuffato", "tulipano", "tumulto", "tunisia", "turbare", "turchino", "tuta", "tutela", "ubicato", "uccello", "uccisore", "udire", "uditivo", "uffa", "ufficio", "uguale", "ulisse", "ultimato", "umano", "umile", "umorismo", "uncinetto", "ungere", "ungherese", "unicorno", "unificato", "unisono", "unitario", "unte", "uovo", "upupa", "uragano", "urgenza", "urlo", "usanza", "usato", "uscito", "usignolo", "usuraio", "utensile", "utilizzo", "utopia", "vacante", "vaccinato", "vagabondo", "vagliato", "valanga", "valgo", "valico", "valletta", "valoroso", "valutare", "valvola", "vampata", "vangare", "vanitoso", "vano", "vantaggio", "vanvera", "vapore", "varano", "varcato", "variante", "vasca", "vedetta", "vedova", "veduto", "vegetale", "veicolo", "velcro", "velina", "velluto", "veloce", "venato", "vendemmia", "vento", "verace", "verbale", "vergogna", "verifica", "vero", "verruca", "verticale", "vescica", "vessillo", "vestale", "veterano", "vetrina", "vetusto", "viandante", "vibrante", "vicenda", "vichingo", "vicinanza", "vidimare", "vigilia", "vigneto", "vigore", "vile", "villano", "vimini", "vincitore", "viola", "vipera", "virgola", "virologo", "virulento", "viscoso", "visione", "vispo", "vissuto", "visura", "vita", "vitello", "vittima", "vivanda", "vivido", "viziare", "voce", "voga", "volatile", "volere", "volpe", "voragine", "vulcano", "zampogna", "zanna", "zappato", "zattera", "zavorra", "zefiro", "zelante", "zelo", "zenzero", "zerbino", "zibetto", "zinco", "zircone", "zitto", "zolla", "zotico", "zucchero", "zufolo", "zulu", "zuppa" };
 
+        /// <summary>
+        /// Italian Constructor
+        /// </summary>
         public Italian() : base(words)
         {
         }
diff --git a/Substrate.NetApi/BIP39/Wordlist.cs b/Substrate.NetApi/BIP39/Wordlist.cs
index 535be33..1fadc3b 100644
--- a/Substrate.NetApi/BIP39/Wordlist.cs
+++ b/Substrate.NetApi/BIP39/Wordlist.cs
@@ -3,15 +3,21 @@
 
 namespace Substrate.NetApi.BIP39
 {
+    /// <summary>
+    /// Base class for all wordlists
+    /// </summary>
     public abstract class Wordlist
     {
-        private String[] _words;
+        /// <summary>
+        /// The words in the wordlist
+        /// </summary>
+        private readonly string[] _words;
 
         /// <summary>
         /// Constructor used by inheritence only
         /// </summary>
         /// <param name="words">The words to be used in the wordlist</param>
-        public Wordlist(String[] words)
+        protected Wordlist(string[] words)
         {
             _words = words;
         }
@@ -20,6 +26,7 @@ public Wordlist(String[] words)
         /// Method to determine if word exists in word list, great for auto language detection
         /// </summary>
         /// <param name="word">The word to check for existence</param>
+        /// <param name="index"></param>
         /// <returns>Exists (true/false)</returns>
         public bool WordExists(string word, out int index)
         {
@@ -55,6 +62,10 @@ public int WordCount
             }
         }
 
+        /// <summary>
+        /// Returns all the words in the wordlist
+        /// </summary>
+        /// <returns></returns>
         public string[] GetWords()
         {
             return _words;
diff --git a/Substrate.NetApi/Base58.cs b/Substrate.NetApi/Base58.cs
index 1456c97..58a8a6c 100644
--- a/Substrate.NetApi/Base58.cs
+++ b/Substrate.NetApi/Base58.cs
@@ -5,12 +5,27 @@
 
 namespace Substrate.NetApi
 {
+    /// <summary>
+    /// Base58 Functions
+    /// </summary>
     public static class Base58Local
     {
+        /// <summary>
+        /// The alphabet used in the Base58 encoding.
+        /// </summary>
         private const string AlphaNumerics = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
+        /// <summary>
+        /// The size of a Base58 check sum in bytes.
+        /// </summary>
         public const int CheckSumSizeInBytes = 4;
 
+        /// <summary>
+        /// Adds a check sum to the given data.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public static byte[] AddCheckSum(byte[] data)
         {
             if (data == null)
@@ -28,6 +43,12 @@ public static byte[] AddCheckSum(byte[] data)
             return result;
         }
 
+        /// <summary>
+        /// Verifies the check sum of the given data and removes the check sum bytes.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public static byte[] VerifyAndRemoveCheckSum(byte[] data)
         {
             if (data == null)
@@ -51,6 +72,12 @@ public static byte[] VerifyAndRemoveCheckSum(byte[] data)
             return givenCheckSum.SequenceEqual(correctCheckSum) ? result : null;
         }
 
+        /// <summary>
+        /// Encodes the given data bytes as a Base58 string.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public static string Encode(byte[] data)
         {
             if (data == null)
@@ -73,6 +100,12 @@ public static string Encode(byte[] data)
             return new string('1', leadingZeros) + result;
         }
 
+        /// <summary>
+        /// Encodes the given data bytes as a Base58 string with a check sum.
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public static string EncodeWithCheckSum(byte[] data)
         {
             if (data == null)
@@ -83,6 +116,13 @@ public static string EncodeWithCheckSum(byte[] data)
             return Encode(AddCheckSum(data));
         }
 
+        /// <summary>
+        /// Decodes the given Base58 string into the original data bytes.
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="FormatException"></exception>
         public static byte[] Decode(string str)
         {
             if (str == null)
@@ -114,6 +154,13 @@ public static byte[] Decode(string str)
             return result;
         }
 
+        /// <summary>
+        /// Decodes the given Base58 string with a check sum into the original data bytes.
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="FormatException"></exception>
         public static byte[] DecodeWithCheckSum(string str)
         {
             if (str == null)
@@ -127,6 +174,12 @@ public static byte[] DecodeWithCheckSum(string str)
             return dataWithoutCheckSum ?? throw new FormatException("Base58 checksum is invalid");
         }
 
+        /// <summary>
+        /// Get Check Sum
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
         private static byte[] GetCheckSum(byte[] data)
         {
             if (data == null)
diff --git a/Substrate.NetApi/CompactInteger.cs b/Substrate.NetApi/CompactInteger.cs
index f3c72c1..adc9fc2 100644
--- a/Substrate.NetApi/CompactInteger.cs
+++ b/Substrate.NetApi/CompactInteger.cs
@@ -9,33 +9,82 @@ namespace Substrate.NetApi
     /// <remarks> 19.09.2020. </remarks>
     public struct CompactInteger : IEncodable
     {
-        /// <summary> Constructor. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="value"> The value. </param>
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(BigInteger value) => Value = value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(I8 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(I16 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(I32 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(I64 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(I128 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(I256 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(U8 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(U16 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(U32 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(U64 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(U128 value) => Value = value.Value;
 
+        /// <summary>
+        /// Value
+        /// </summary>
+        /// <param name="value"></param>
         public CompactInteger(U256 value) => Value = value.Value;
 
         /// <summary> Indicates whether this instance and a specified object are equal. </summary>
diff --git a/Substrate.NetApi/Constants.cs b/Substrate.NetApi/Constants.cs
index 4c47af8..1a9943e 100644
--- a/Substrate.NetApi/Constants.cs
+++ b/Substrate.NetApi/Constants.cs
@@ -1,7 +1,13 @@
 namespace Substrate.NetApi
 {
-    public class Constants
+    /// <summary>
+    /// Constants
+    /// </summary>
+    public static class Constants
     {
+        /// <summary>
+        /// The default era period
+        /// </summary>
         public const ulong ExtrinsicEraPeriodDefault = 64;
 
         /// <summary>The extrinsic version</summary>
@@ -9,8 +15,11 @@ public class Constants
 
         // https://github.com/paritytech/substrate/blob/c0cb70419798eb7fd38806da668bec05f8cfd7f1/primitives/runtime/src/generic/unchecked_extrinsic.rs#L33
 
-        // https://polkadot.js.org/docs/api/FAQ/
-        // 0 = AccountId (no prefix), 1 = IndicesLookup (0xFF), 2 = MutiAddress (https://github.com/paritytech/substrate/pull/7380)
+        /// <summary>
+        /// The address version
+        ///  https://polkadot.js.org/docs/api/FAQ/
+        ///  0 = AccountId (no prefix), 1 = IndicesLookup (0xFF), 2 = MutiAddress (https://github.com/paritytech/substrate/pull/7380)
+        /// </summary>
         public static uint AddressVersion = 2;
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Exceptions/ClientNotConnectedException.cs b/Substrate.NetApi/Exceptions/ClientNotConnectedException.cs
index 079c148..0044b5d 100644
--- a/Substrate.NetApi/Exceptions/ClientNotConnectedException.cs
+++ b/Substrate.NetApi/Exceptions/ClientNotConnectedException.cs
@@ -2,8 +2,16 @@
 
 namespace Substrate.NetApi.Exceptions
 {
+
+    /// <summary>
+    /// Client Not Connected Exception
+    /// </summary>
     public class ClientNotConnectedException : Exception
     {
+        /// <summary>
+        /// Client Not Connected Exception
+        /// </summary>
+        /// <param name="message"></param>
         public ClientNotConnectedException(string message)
             : base(message)
         { }
diff --git a/Substrate.NetApi/Exceptions/ConverterAlreadyRegisteredException.cs b/Substrate.NetApi/Exceptions/ConverterAlreadyRegisteredException.cs
index 1ebe02f..83385cd 100644
--- a/Substrate.NetApi/Exceptions/ConverterAlreadyRegisteredException.cs
+++ b/Substrate.NetApi/Exceptions/ConverterAlreadyRegisteredException.cs
@@ -2,8 +2,15 @@
 
 namespace Substrate.NetApi.Exceptions
 {
+    /// <summary>
+    /// Converter Already Registered Exception
+    /// </summary>
     public class ConverterAlreadyRegisteredException : Exception
     {
+        /// <summary>
+        /// Converter Already Registered Exception
+        /// </summary>
+        /// <param name="message"></param>
         public ConverterAlreadyRegisteredException(string message)
             : base(message)
         { }
diff --git a/Substrate.NetApi/Exceptions/MissingConverterException.cs b/Substrate.NetApi/Exceptions/MissingConverterException.cs
index 22f41b9..a2a4c67 100644
--- a/Substrate.NetApi/Exceptions/MissingConverterException.cs
+++ b/Substrate.NetApi/Exceptions/MissingConverterException.cs
@@ -2,8 +2,15 @@
 
 namespace Substrate.NetApi.Exceptions
 {
+    /// <summary>
+    /// Missing Converter Exception
+    /// </summary>
     public class MissingConverterException : Exception
     {
+        /// <summary>
+        /// Missing Converter Exception
+        /// </summary>
+        /// <param name="message"></param>
         public MissingConverterException(string message) :
             base(message)
         { }
diff --git a/Substrate.NetApi/Exceptions/MissingModuleOrItemException.cs b/Substrate.NetApi/Exceptions/MissingModuleOrItemException.cs
index 550dd29..ddf0bcc 100644
--- a/Substrate.NetApi/Exceptions/MissingModuleOrItemException.cs
+++ b/Substrate.NetApi/Exceptions/MissingModuleOrItemException.cs
@@ -2,8 +2,15 @@
 
 namespace Substrate.NetApi.Exceptions
 {
+    /// <summary>
+    /// Missing Module Or Item Exception
+    /// </summary>
     public class MissingModuleOrItemException : Exception
     {
+        /// <summary>
+        /// Missing Module Or Item Exception
+        /// </summary>
+        /// <param name="message"></param>
         public MissingModuleOrItemException(string message)
             : base(message)
         {
diff --git a/Substrate.NetApi/Exceptions/MissingParameterException.cs b/Substrate.NetApi/Exceptions/MissingParameterException.cs
index 4fe75b8..fe0af91 100644
--- a/Substrate.NetApi/Exceptions/MissingParameterException.cs
+++ b/Substrate.NetApi/Exceptions/MissingParameterException.cs
@@ -2,8 +2,15 @@
 
 namespace Substrate.NetApi.Exceptions
 {
+    /// <summary>
+    /// Missing Parameter Exception
+    /// </summary>
     public class MissingParameterException : Exception
     {
+        /// <summary>
+        /// Missing Parameter Exception
+        /// </summary>
+        /// <param name="message"></param>
         public MissingParameterException(string message)
             : base(message)
         { }
diff --git a/Substrate.NetApi/Extensions/BytesExtension.cs b/Substrate.NetApi/Extensions/BytesExtension.cs
index f4e37a8..44efb9f 100644
--- a/Substrate.NetApi/Extensions/BytesExtension.cs
+++ b/Substrate.NetApi/Extensions/BytesExtension.cs
@@ -6,6 +6,9 @@
 
 namespace Substrate.NetApi.Extensions
 {
+    /// <summary>
+    /// Bytes Extension
+    /// </summary>
     public static class BytesExtension
     {
         private static readonly RandomNumberGenerator RandomGenerator = RandomNumberGenerator.Create();
@@ -21,6 +24,13 @@ public static byte[] Populate(this byte[] data)
             return data;
         }
 
+        /// <summary>
+        /// Convert bytes to hex
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="bitLength"></param>
+        /// <param name="atStart"></param>
+        /// <returns></returns>
         public static byte[] BytesFixLength(this byte[] value, int bitLength = -1, bool atStart = false)
         {
             int byteLength = (bitLength == -1) ? value.Length : (int)Math.Ceiling(bitLength / 8.0);
diff --git a/Substrate.NetApi/Extensions/StringExtension.cs b/Substrate.NetApi/Extensions/StringExtension.cs
index 4c8148d..a4cc704 100644
--- a/Substrate.NetApi/Extensions/StringExtension.cs
+++ b/Substrate.NetApi/Extensions/StringExtension.cs
@@ -4,13 +4,26 @@
 
 namespace Substrate.NetApi.Extensions
 {
+    /// <summary>
+    /// String Extension
+    /// </summary>
     public static class StringExtension
     {
+        /// <summary>
+        /// Convert string to bytes
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
         public static byte[] ToBytes(this string value)
         {
             return Encoding.UTF8.GetBytes(value);
         }
 
+        /// <summary>
+        /// Convert string to hex
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
         public static bool IsHex(this string value)
         {
             if (string.IsNullOrEmpty(value))
@@ -22,7 +35,12 @@ public static bool IsHex(this string value)
             return value.Length % 2 == 0 && IsHexCharacters(value);
         }
 
-        private static bool IsHexCharacters(string input)
+        /// <summary>
+        /// Convert string to hex
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        internal static bool IsHexCharacters(string input)
         {
             foreach (char c in input)
             {
@@ -34,7 +52,12 @@ private static bool IsHexCharacters(string input)
             return true;
         }
 
-        private static bool IsHexDigit(char c)
+        /// <summary>
+        /// Convert string to hex
+        /// </summary>
+        /// <param name="c"></param>
+        /// <returns></returns>
+        internal static bool IsHexDigit(char c)
         {
             return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
         }
diff --git a/Substrate.NetApi/HashExtension.cs b/Substrate.NetApi/HashExtension.cs
index 811dab9..202fb6f 100644
--- a/Substrate.NetApi/HashExtension.cs
+++ b/Substrate.NetApi/HashExtension.cs
@@ -7,6 +7,9 @@
 
 namespace Substrate.NetApi
 {
+    /// <summary>
+    /// Hash extension.
+    /// </summary>
     public class HashExtension
     {
         /// <summary>
@@ -116,7 +119,7 @@ public static byte[] Twox256(byte[] bytes)
         /// </returns>
         public static byte[] Twox64Concat(byte[] bytes)
         {
-            return BitConverter.GetBytes(XXHash.XXH64(bytes)).Concat(bytes).ToArray().ToArray();
+            return BitConverter.GetBytes(XXHash.XXH64(bytes)).Concat(bytes).ToArray();
         }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Mnemonic.cs b/Substrate.NetApi/Mnemonic.cs
index 20553a7..de37587 100644
--- a/Substrate.NetApi/Mnemonic.cs
+++ b/Substrate.NetApi/Mnemonic.cs
@@ -11,19 +11,64 @@
 
 namespace Substrate.NetApi
 {
+    /// <summary>
+    /// Mnemonic
+    /// </summary>
     public static class Mnemonic
     {
+        /// <summary>
+        /// BIP39 Wordlist
+        /// </summary>
         public enum BIP39Wordlist
         {
+            /// <summary>
+            /// English
+            /// </summary>
             English,
+
+            /// <summary>
+            /// Japanese
+            /// </summary>
             Japanese,
+
+            /// <summary>
+            /// Korean
+            /// </summary>
             Korean,
+
+            /// <summary>
+            /// Spanish
+            /// </summary>
             Spanish,
+
+            /// <summary>
+            /// Chinese Simplified
+            /// </summary>
             ChineseSimplified,
+
+            /// <summary>
+            /// Chinese Traditional
+            /// </summary>
             ChineseTraditional,
+
+            /// <summary>
+            /// French
+            /// </summary>
             French,
+
+            /// <summary>
+            /// Italian
+            /// </summary>
             Italian,
+
+            /// <summary>
+            /// Czech
+            /// </summary>
             Czech,
+
+            /// <summary>
+            /// Portuguese
+            /// </summary>
             Portuguese
         }
 
@@ -195,6 +240,14 @@ public static Account GetAccountFromMnemonic(string mnemonic, string password, K
             }
         }
 
+        /// <summary>
+        /// Get entropy from mnemonic
+        /// </summary>
+        /// <param name="mnemonic"></param>
+        /// <param name="wordlistType"></param>
+        /// <returns></returns>
+        /// <exception cref="FormatException"></exception>
+        /// <exception cref="NotSupportedException"></exception>
         public static string MnemonicToEntropy(string mnemonic, BIP39Wordlist wordlistType)
         {
             var wordlist = GetWordlist(wordlistType);
@@ -234,7 +287,7 @@ public static string MnemonicToEntropy(string mnemonic, BIP39Wordlist wordlistTy
             var newChecksum = DeriveChecksumBits(entropyBytes);
 
             if (newChecksum != checksumBits)
-                throw new Exception("InvalidChecksum");
+                throw new NotSupportedException("InvalidChecksum");
 
             var result = BitConverter
                 .ToString(entropyBytes)
@@ -259,7 +312,7 @@ private static void CheckValidEntropy(byte[] entropyBytes)
         private static string DeriveChecksumBits(byte[] entropyBytes)
         {
             var ent = entropyBytes.Length * 8;
-            var cs = (int)ent / 32;
+            var cs = ent / 32;
 
             var sha256Provider = SHA256.Create();
             var hash = sha256Provider.ComputeHash(entropyBytes);
@@ -302,16 +355,38 @@ private static Wordlist GetWordlist(BIP39Wordlist language)
                     return new Portuguese();
 
                 default:
-                    throw new Exception($"Unknown {language} in BIP39 implementation!");
+                    throw new NotSupportedException($"Unknown {language} in BIP39 implementation!");
             }
         }
 
+        /// <summary>
+        /// Mnemonic size
+        /// </summary>
         public enum MnemonicSize
         {
+            /// <summary>
+            /// Words 12
+            /// </summary>
             Words12,
+
+            /// <summary>
+            /// Words 15
+            /// </summary>
             Words15,
+
+            /// <summary>
+            /// Words 18 
+            /// </summary>
             Words18,
+
+            /// <summary>
+            /// Words 21
+            /// </summary>
             Words21,
+
+            /// <summary>
+            /// Words 24
+            /// </summary>
             Words24
         }
 
@@ -340,16 +415,12 @@ public static string[] GenerateMnemonic(MnemonicSize mnemonicSize, BIP39Wordlist
             throw new InvalidOperationException("Invalid mnemonic size");
         }
 
-        //public static byte[] MnemonicToMiniSecret(string mnemonic, string password, BIP39Wordlist bIP39Wordlist = BIP39Wordlist.English)
-        //{
-        //    if (!ValidateMnemonic(mnemonic, bIP39Wordlist))
-        //    {
-        //        throw new InvalidOperationException("Invalid bip39 mnemonic specified");
-        //    }
-
-        //    return GetSecretKeyFromMnemonic(mnemonic, password, bIP39Wordlist);
-        //}
-
+        /// <summary>
+        /// Validate mnemonic
+        /// </summary>
+        /// <param name="mnemonic"></param>
+        /// <param name="bIP39Wordlist"></param>
+        /// <returns></returns>
         public static bool ValidateMnemonic(string mnemonic, BIP39Wordlist bIP39Wordlist = BIP39Wordlist.English)
         {
             try
diff --git a/Substrate.NetApi/Model/Extrinsics/ChargeAssetTxPayment.cs b/Substrate.NetApi/Model/Extrinsics/ChargeAssetTxPayment.cs
index 97704c0..38ee08f 100644
--- a/Substrate.NetApi/Model/Extrinsics/ChargeAssetTxPayment.cs
+++ b/Substrate.NetApi/Model/Extrinsics/ChargeAssetTxPayment.cs
@@ -3,20 +3,32 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Charge Type
+    /// </summary>
     public abstract class ChargeType : BaseType
     { }
 
+    /// <summary>
+    /// Charge Asset Tx Payment
+    /// </summary>
     public class ChargeAssetTxPayment : ChargeType
     {
         private CompactInteger _tip;
         private CompactInteger _assetId;
 
+        /// <summary>
+        /// Charge Asset Tx Payment Constructor
+        /// </summary>
+        /// <param name="tip"></param>
+        /// <param name="asset"></param>
         public ChargeAssetTxPayment(CompactInteger tip, CompactInteger asset)
         {
             _tip = tip;
             _assetId = asset;
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var bytes = new List<byte>();
@@ -30,27 +42,40 @@ public override byte[] Encode()
             return bytes.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             _tip = CompactInteger.Decode(byteArray, ref p);
             _assetId = CompactInteger.Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// Default
+        /// </summary>
+        /// <returns></returns>
         public static ChargeAssetTxPayment Default()
         {
             return new ChargeAssetTxPayment(0, 0);
         }
     }
 
+    /// <summary>
+    /// Charge Transaction Payment
+    /// </summary>
     public class ChargeTransactionPayment : ChargeType
     {
         private CompactInteger _tip;
 
+        /// <summary>
+        /// Charge Transaction Payment Constructor
+        /// </summary>
+        /// <param name="tip"></param>
         public ChargeTransactionPayment(CompactInteger tip)
         {
             _tip = tip;
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var bytes = new List<byte>();
@@ -61,11 +86,16 @@ public override byte[] Encode()
             return bytes.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             _tip = CompactInteger.Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// Default
+        /// </summary>
+        /// <returns></returns>
         public static ChargeTransactionPayment Default()
         {
             return new ChargeTransactionPayment(0);
diff --git a/Substrate.NetApi/Model/Extrinsics/Era.cs b/Substrate.NetApi/Model/Extrinsics/Era.cs
index 112f69e..d80ff82 100644
--- a/Substrate.NetApi/Model/Extrinsics/Era.cs
+++ b/Substrate.NetApi/Model/Extrinsics/Era.cs
@@ -4,14 +4,31 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Era
+    /// </summary>
     public class Era : IEncodable
     {
+        /// <summary>
+        /// Is Immortal
+        /// </summary>
         public bool IsImmortal { get; }
 
+        /// <summary>
+        /// Period
+        /// </summary>
         public ulong Period { get; }
 
+        /// <summary>
+        /// Phase
+        /// </summary>
         public ulong Phase { get; }
 
+        /// <summary>
+        /// Era Start
+        /// </summary>
+        /// <param name="currentBlockNumber"></param>
+        /// <returns></returns>
         public ulong EraStart(ulong currentBlockNumber) => IsImmortal ? 0 : (Math.Max(currentBlockNumber, Phase) - Phase) / Period * Period + Phase;
 
         /// <summary>
@@ -27,6 +44,7 @@ public Era(ulong period, ulong phase, bool isImmortal)
             IsImmortal = isImmortal;
         }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
@@ -47,17 +65,6 @@ public static Era Create(uint lifeTime, ulong finalizedHeaderBlockNumber)
 
             // NODE: { "IsImmortal":false,"Period":64,"Phase":49}
             // API: { "IsImmortal":false,"Period":64,"Phase":61}
-
-            // RUST Implementation
-            //let period = period.checked_next_power_of_two()
-            //    .unwrap_or(1 << 16)
-            //    .max(4)
-            //    .min(1 << 16);
-            //let phase = current % period;
-            //let quantize_factor = (period >> 12).max(1);
-            //let quantized_phase = phase / quantize_factor * quantize_factor;
-            //Era::Mortal(period, quantized_phase)
-
             ulong period = (ulong)Math.Pow(2, Math.Round(Math.Log(lifeTime, 2)));
             period = Math.Max(period, 4);
             period = Math.Min(period, 65536);
@@ -80,13 +87,6 @@ public byte[] Encode()
             }
             var quantizeFactor = Math.Max(1, Period / 4096);
             var lastBit = Period & (ulong)-(long)Period;
-            //var rest = _period;
-            //var lastBit = 1;
-            //while (rest % 2 == 0 && rest != 0)
-            //{
-            //    rest /= 2;
-            //    lastBit *= 2;
-            //}
             var logOf2 = lastBit != 0 ? Math.Log(lastBit, 2) : 64;
             var low = (ushort)Math.Min(15, Math.Max(1, logOf2 - 1));
             var high = (ushort)(Phase / quantizeFactor << 4);
@@ -127,7 +127,7 @@ public static Era Decode(byte[] bytes)
             }
             else
             {
-                throw new Exception("Invalid byte array to get era.");
+                throw new NotSupportedException("Invalid byte array to get era.");
             }
         }
     }
diff --git a/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs b/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs
index cd5b709..877d6de 100644
--- a/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs
+++ b/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs
@@ -5,29 +5,56 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Extrinsic
+    /// </summary>
     public class Extrinsic
     {
-        public bool Signed;
+        /// <summary>
+        /// Signed
+        /// </summary>
+        public bool Signed { get; set; }
 
-        public byte TransactionVersion;
+        /// <summary>
+        /// Transaction Version
+        /// </summary>
+        public byte TransactionVersion { get; set; }
 
-        //[JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public Account Account;
+        /// <summary>
+        /// Account
+        /// </summary>
+        public Account Account { get; set; }
 
-        public Era Era;
+        /// <summary>
+        /// Era
+        /// </summary>
+        public Era Era { get; set; }
 
-        public CompactInteger Nonce;
+        /// <summary>
+        /// Nonce
+        /// </summary>
+        public CompactInteger Nonce { get; set; }
 
-        public ChargeType Charge;
+        /// <summary>
+        /// Charge
+        /// </summary>
+        public ChargeType Charge { get; set; }
 
-        public Method Method;
+        /// <summary>
+        /// Method
+        /// </summary>
+        public Method Method { get; set; }
 
-        public byte[] Signature;
+        /// <summary>
+        /// Signature
+        /// </summary>
+        public byte[] Signature { get; set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Extrinsic"/> class.
         /// </summary>
         /// <param name="str">The string.</param>
+        /// <param name="chargeType"></param>
         public Extrinsic(string str, ChargeType chargeType) : this(Utils.HexToByteArray(str).AsMemory(), chargeType)
         {
         }
@@ -116,7 +143,7 @@ internal Extrinsic(Memory<byte> memory, ChargeType chargeType)
         /// <param name="nonce">The nonce.</param>
         /// <param name="method">The method.</param>
         /// <param name="era">The era.</param>
-        /// <param name="tip">The tip.</param>
+        /// <param name="charge"></param>
         public Extrinsic(bool signed, Account account, CompactInteger nonce, Method method, Era era, ChargeType charge)
         {
             Signed = signed;
@@ -128,6 +155,10 @@ public Extrinsic(bool signed, Account account, CompactInteger nonce, Method meth
             Method = method;
         }
 
+        /// <summary>
+        /// Encodes this instance.
+        /// </summary>
+        /// <returns></returns>
         public byte[] Encode()
         {
             var result = new List<byte>();
@@ -153,6 +184,7 @@ public byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Extrinsics/Method.cs b/Substrate.NetApi/Model/Extrinsics/Method.cs
index d40fa6e..b19dfe5 100644
--- a/Substrate.NetApi/Model/Extrinsics/Method.cs
+++ b/Substrate.NetApi/Model/Extrinsics/Method.cs
@@ -3,17 +3,35 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Method
+    /// </summary>
     public class Method
     {
-        public string ModuleName;
+        /// <summary>
+        /// Module Name
+        /// </summary>
+        public string ModuleName { get; set; }
 
-        public byte ModuleIndex;
+        /// <summary>
+        /// Module Index
+        /// </summary>
+        public byte ModuleIndex { get; set; }
 
-        public string CallName;
+        /// <summary>
+        /// Call Name
+        /// </summary>
+        public string CallName { get; set; }
 
-        public byte CallIndex;
+        /// <summary>
+        /// Call Index
+        /// </summary>
+        public byte CallIndex { get; set; }
 
-        public byte[] Parameters;
+        /// <summary>
+        /// Parameters
+        /// </summary>
+        public byte[] Parameters { get; set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Method"/> class.
@@ -43,8 +61,10 @@ public Method(byte moduleIndex, byte callIndex)
         /// <summary>
         /// Initializes a new instance of the <see cref="Method"/> class.
         /// </summary>
-        /// <param name="module">The module.</param>
-        /// <param name="call">The call.</param>
+        /// <param name="moduleIndex">Index of the module.</param>
+        /// <param name="moduleName">Name of the module.</param>
+        /// <param name="callIndex">Index of the call.</param>
+        /// <param name="callName">Name of the call.</param>
         /// <param name="parameters">The parameters.</param>
         public Method(byte moduleIndex, string moduleName, byte callIndex, string callName, byte[] parameters)
         {
@@ -68,6 +88,7 @@ public byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Extrinsics/Payload.cs b/Substrate.NetApi/Model/Extrinsics/Payload.cs
index 950dbb0..5199b10 100644
--- a/Substrate.NetApi/Model/Extrinsics/Payload.cs
+++ b/Substrate.NetApi/Model/Extrinsics/Payload.cs
@@ -2,10 +2,14 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Payload
+    /// </summary>
     public class Payload
     {
-        private Method _call;
-        private SignedExtensions _signedExtension;
+        private readonly Method _call;
+        
+        private readonly SignedExtensions _signedExtension;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Payload"/> class.
diff --git a/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs b/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs
index 8f932d0..b9a3870 100644
--- a/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs
+++ b/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs
@@ -3,21 +3,24 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Signed Extensions
+    /// </summary>
     public class SignedExtensions
     {
-        private uint _specVersion;
+        private readonly uint _specVersion;
 
-        private uint _txVersion;
+        private readonly uint _txVersion;
 
-        private Hash _genesis;
+        private readonly Hash _genesis;
 
-        private Hash _startEra;
+        private readonly Hash _startEra;
 
-        private Era _mortality;
+        private readonly Era _mortality;
 
-        private CompactInteger _nonce;
+        private readonly CompactInteger _nonce;
 
-        private ChargeType _charge;
+        private readonly ChargeType _charge;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedExtensions"/> class.
diff --git a/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs b/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs
index 490a6fc..f2d77ef 100644
--- a/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs
+++ b/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs
@@ -20,7 +20,7 @@ public class UnCheckedExtrinsic : Extrinsic
         /// <param name="method">The method.</param>
         /// <param name="era">The era.</param>
         /// <param name="nonce">The nonce.</param>
-        /// <param name="tip">The tip.</param>
+        /// <param name="charge"></param>
         /// <param name="genesis">The genesis.</param>
         /// <param name="startEra">The start era.</param>
         public UnCheckedExtrinsic(bool signed, Account account, Method method, Era era, CompactInteger nonce, ChargeType charge, Hash genesis, Hash startEra)
@@ -58,7 +58,7 @@ public byte[] Encode()
         {
             if (Signed && Signature == null)
             {
-                throw new Exception("Missing payload signature for signed transaction.");
+                throw new NotSupportedException("Missing payload signature for signed transaction.");
             }
 
             var list = new List<byte>();
@@ -77,9 +77,6 @@ public byte[] Encode()
             {
                 list.AddRange(Signature);
             }
-            else
-            {
-            }
 
             list.AddRange(Era.Encode());
 
diff --git a/Substrate.NetApi/Model/Meta/MetaData.cs b/Substrate.NetApi/Model/Meta/MetaData.cs
index 2e12cb0..54b4142 100644
--- a/Substrate.NetApi/Model/Meta/MetaData.cs
+++ b/Substrate.NetApi/Model/Meta/MetaData.cs
@@ -8,8 +8,16 @@
 
 namespace Substrate.NetApi.Model.Meta
 {
+    /// <summary>
+    /// Meta Data
+    /// </summary>
     public class MetaData
     {
+        /// <summary>
+        /// Meta Data Constructor
+        /// </summary>
+        /// <param name="rtmd"></param>
+        /// <param name="origin"></param>
         public MetaData(RuntimeMetadata rtmd, string origin = "unknown")
         {
             Origin = origin;
@@ -24,16 +32,40 @@ public MetaData(RuntimeMetadata rtmd, string origin = "unknown")
             };
         }
 
+        /// <summary>
+        /// Origin
+        /// </summary>
         public string Origin { get; set; }
+        
+        /// <summary>
+        /// Magic
+        /// </summary>
         public string Magic { get; set; }
+        
+        /// <summary>
+        /// Version
+        /// </summary>
         public byte Version { get; set; }
+
+        /// <summary>
+        /// Node Metadata
+        /// </summary>
         public NodeMetadataV14 NodeMetadata { get; set; }
 
+        /// <summary>
+        /// Serialize
+        /// </summary>
+        /// <returns></returns>
         public string Serialize()
         {
             return JsonConvert.SerializeObject(this, new StringEnumConverter());
         }
 
+        /// <summary>
+        /// Create Node Type Dictionary
+        /// </summary>
+        /// <param name="types"></param>
+        /// <returns></returns>
         public static Dictionary<uint, NodeType> CreateNodeTypeDict(PortableType[] types)
         {
             var result = new Dictionary<uint, NodeType>();
@@ -217,6 +249,12 @@ public static Dictionary<uint, NodeType> CreateNodeTypeDict(PortableType[] types
             return result;
         }
 
+        /// <summary>
+        /// Create Module Dictionary
+        /// </summary>
+        /// <param name="modules"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
         public static Dictionary<uint, PalletModule> CreateModuleDict(PalletMetadata[] modules)
         {
             var result = new Dictionary<uint, PalletModule>();
@@ -318,6 +356,11 @@ public static Dictionary<uint, PalletModule> CreateModuleDict(PalletMetadata[] m
             return result;
         }
 
+        /// <summary>
+        /// Create Extrinsic
+        /// </summary>
+        /// <param name="extrinsic"></param>
+        /// <returns></returns>
         private static ExtrinsicMetadata CreateExtrinsic(ExtrinsicMetadataStruct extrinsic)
         {
             return new ExtrinsicMetadata()
diff --git a/Substrate.NetApi/Model/Meta/MetadataTree.cs b/Substrate.NetApi/Model/Meta/MetadataTree.cs
index 7b675a5..8d531ef 100644
--- a/Substrate.NetApi/Model/Meta/MetadataTree.cs
+++ b/Substrate.NetApi/Model/Meta/MetadataTree.cs
@@ -5,188 +5,458 @@
 
 namespace Substrate.NetApi.Model.Meta
 {
+    /// <summary>
+    /// Node Type
+    /// </summary>
     public class NodeType
     {
+        /// <summary>
+        /// Id
+        /// </summary>
         [JsonIgnore]
         public uint Id { get; set; }
 
+        /// <summary>
+        /// Path
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string[] Path { get; set; }
 
+        /// <summary>
+        /// Type Params
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public NodeTypeParam[] TypeParams { get; set; }
 
+        /// <summary>
+        /// Type Def Enum
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public TypeDefEnum TypeDef { get; set; }
 
+        /// <summary>
+        /// Docs
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string[] Docs { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Param
+    /// </summary>
     public class NodeTypeParam
     {
+        /// <summary>
+        /// Name
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; set; }
 
+        /// <summary>
+        /// Type Id
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public uint? TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Primitive
+    /// </summary>
     public class NodeTypePrimitive : NodeType
     {
+        /// <summary>
+        /// Primitive
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public TypeDefPrimitive Primitive { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Composite
+    /// </summary>
     public class NodeTypeComposite : NodeType
     {
+        /// <summary>
+        /// Type Fields
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public NodeTypeField[] TypeFields { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Field
+    /// </summary>
     public class NodeTypeField
     {
+        /// <summary>
+        /// Name
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string Name { get; set; }
 
+        /// <summary>
+        /// Type Name
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string TypeName { get; set; }
 
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
 
+        /// <summary>
+        /// Docs
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string[] Docs { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Array
+    /// </summary>
     public class NodeTypeArray : NodeType
     {
+        /// <summary>
+        /// Length
+        /// </summary>
         public uint Length { get; set; }
 
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Sequence
+    /// </summary>
     public class NodeTypeSequence : NodeType
     {
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Compact
+    /// </summary>
     public class NodeTypeCompact : NodeType
     {
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Tuple
+    /// </summary>
     public class NodeTypeTuple : NodeType
     {
+        /// <summary>
+        /// Type Ids
+        /// </summary>
         public uint[] TypeIds { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Bit Sequence
+    /// </summary>
     public class NodeTypeBitSequence : NodeType
     {
+        /// <summary>
+        /// Type Id Store
+        /// </summary>
         public uint TypeIdStore { get; set; }
+
+        /// <summary>
+        /// Type Id Order
+        /// </summary>
         public uint TypeIdOrder { get; set; }
     }
 
+    /// <summary>
+    /// Node Type Variant
+    /// </summary>
     public class NodeTypeVariant : NodeType
     {
+        /// <summary>
+        /// Variants
+        /// </summary>
         public TypeVariant[] Variants { get; set; }
     }
 
+    /// <summary>
+    /// Type Variant
+    /// </summary>
     public class TypeVariant
     {
+        /// <summary>
+        /// Name
+        /// </summary>
         public string Name { get; set; }
+
+        /// <summary>
+        /// Type Fields
+        /// </summary>
         public NodeTypeField[] TypeFields { get; set; }
 
+        /// <summary>
+        /// Index
+        /// </summary>
         public int Index { get; set; }
 
+        /// <summary>
+        /// Docs
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string[] Docs { get; set; }
     }
-
+    
+    /// <summary>
+    /// Node Metadata V14
+    /// </summary>
     public class NodeMetadataV14
     {
+        /// <summary>
+        /// Types
+        /// </summary>
         public Dictionary<uint, NodeType> Types { get; set; }
+
+        /// <summary>
+        /// Modules
+        /// </summary>
         public Dictionary<uint, PalletModule> Modules { get; set; }
+
+        /// <summary>
+        /// Extrinsic
+        /// </summary>
         public ExtrinsicMetadata Extrinsic { get; set; }
+
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Signed Extension Metadata
+    /// </summary>
     public class SignedExtensionMetadata
     {
+        /// <summary>
+        /// Signed Identifier
+        /// </summary>
         public string SignedIdentifier { get; set; }
+
+        /// <summary>
+        /// Signed Ext Type
+        /// </summary>
         public uint SignedExtType { get; set; }
+
+        /// <summary>
+        /// Add Signed Ext Type
+        /// </summary>
         public uint AddSignedExtType { get; set; }
     }
 
+    /// <summary>
+    /// Extrinsic Metadata
+    /// </summary>
     public class ExtrinsicMetadata
     {
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
+
+        /// <summary>
+        /// Version
+        /// </summary>
         public int Version { get; set; }
+
+        /// <summary>
+        /// Signed Extensions
+        /// </summary>
         public SignedExtensionMetadata[] SignedExtensions { get; set; }
     }
 
+    /// <summary>
+    /// Pallet Constant
+    /// </summary>
     public class PalletConstant
     {
+        /// <summary>
+        /// Name
+        /// </summary>
         public string Name { get; set; }
+
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
+
+        /// <summary>
+        /// Value
+        /// </summary>
         public byte[] Value { get; set; }
+
+        /// <summary>
+        /// Docs
+        /// </summary>
         public string[] Docs { get; set; }
     }
 
+    /// <summary>
+    /// Pallet Storage
+    /// </summary>
     public class PalletStorage
     {
+        /// <summary>
+        /// Prefix
+        /// </summary>
         public string Prefix { get; set; }
+
+        /// <summary>
+        /// Entries
+        /// </summary>
         public Entry[] Entries { get; set; }
     }
 
+    /// <summary>
+    /// Entry
+    /// </summary>
     public class Entry
     {
+        /// <summary>
+        /// Name
+        /// </summary>
         public string Name { get; set; }
 
+        /// <summary>
+        /// Modifier
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public Storage.Modifier Modifier { get; set; }
 
+        /// <summary>
+        /// Storage Type
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public Storage.Type StorageType { get; set; }
 
+        /// <summary>
+        /// Type Map
+        /// </summary>
         public (uint, TypeMap) TypeMap { get; set; }
+        
+        /// <summary>
+        /// Default
+        /// </summary>
         public byte[] Default { get; set; }
 
+        /// <summary>
+        /// Docs
+        /// </summary>
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public string[] Docs { get; set; }
     }
 
+    /// <summary>
+    /// Type Map
+    /// </summary>
     public class TypeMap
     {
+        /// <summary>
+        /// Hashers
+        /// </summary>
         [JsonProperty("Hashers", ItemConverterType = typeof(StringEnumConverter))]
         public Storage.Hasher[] Hashers { get; set; }
 
+        /// <summary>
+        /// Key
+        /// </summary>
         public uint Key { get; set; }
+        
+        /// <summary>
+        /// Value
+        /// </summary>
         public uint Value { get; set; }
     }
 
+    /// <summary>
+    /// Pallet Module
+    /// </summary>
     public class PalletModule
     {
+        /// <summary>
+        /// Name
+        /// </summary>
         public string Name { get; set; }
+        
+        /// <summary>
+        /// Storage
+        /// </summary>
         public PalletStorage Storage { get; set; }
+
+        /// <summary>
+        /// Calls
+        /// </summary>
         public PalletCalls Calls { get; set; }
+
+        /// <summary>
+        /// Events
+        /// </summary>
         public PalletEvents Events { get; set; }
+
+        /// <summary>
+        /// Constants
+        /// </summary>
         public PalletConstant[] Constants { get; set; }
+
+        /// <summary>
+        /// Errors
+        /// </summary>
         public PalletErrors Errors { get; set; }
+
+        /// <summary>
+        /// Index
+        /// </summary>
         public uint Index { get; set; }
     }
 
+    /// <summary>
+    /// Pallete Calls
+    /// </summary>
     public class PalletCalls
     {
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Pallet Events
+    /// </summary>
     public class PalletEvents
     {
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 
+    /// <summary>
+    /// Pallet Errors
+    /// </summary>
     public class PalletErrors
     {
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public uint TypeId { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Meta/Storage.cs b/Substrate.NetApi/Model/Meta/Storage.cs
index 1e6770d..cf978af 100644
--- a/Substrate.NetApi/Model/Meta/Storage.cs
+++ b/Substrate.NetApi/Model/Meta/Storage.cs
@@ -1,30 +1,95 @@
 namespace Substrate.NetApi.Model.Meta
 {
+    /// <summary>
+    /// Storage
+    /// </summary>
     public class Storage
     {
+        /// <summary>
+        /// Storage Type Enum
+        /// </summary>
         public enum Type
         {
+            /// <summary>
+            /// Plain
+            /// </summary>
             Plain,
+
+            /// <summary>
+            /// Map
+            /// </summary>
             Map,
+
+            /// <summary>
+            /// Double Map
+            /// </summary>
             DoubleMap,
+
+            /// <summary>
+            /// NMap
+            /// </summary>
             NMap
         }
 
+        /// <summary>
+        /// Storage Modifier Enum
+        /// </summary>
         public enum Modifier
         {
+            /// <summary>
+            /// Optional
+            /// </summary>
             Optional,
+
+            /// <summary>
+            /// Default
+            /// </summary>
             Default
         }
 
+        /// <summary>
+        /// Storage Hasher Enum
+        /// </summary>
         public enum Hasher
         {
+            /// <summary>
+            /// None
+            /// </summary>
             None = -1,
+
+            /// <summary>
+            /// Blake2 128
+            /// </summary>
             BlakeTwo128,
+
+            /// <summary>
+            /// Blake2 256
+            /// </summary>
             BlakeTwo256,
+
+            /// <summary>
+            /// Blake2 128 Concat
+            /// </summary>
             BlakeTwo128Concat,
+
+            /// <summary>
+            /// Twox 128
+            /// </summary>
             Twox128,
+
+            /// <summary>
+            /// Twox 256
+            /// </summary>
             Twox256,
+
+            /// <summary>
+            /// Twox 64 Concat
+            /// </summary>
             Twox64Concat,
+
+            /// <summary>
+            /// Identity
+            /// </summary>
             Identity
         }
     }
diff --git a/Substrate.NetApi/Model/Rpc/Block.cs b/Substrate.NetApi/Model/Rpc/Block.cs
index 3cacc66..32ea1e6 100644
--- a/Substrate.NetApi/Model/Rpc/Block.cs
+++ b/Substrate.NetApi/Model/Rpc/Block.cs
@@ -2,9 +2,19 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Block
+    /// </summary>
     public class Block
     {
+        /// <summary>
+        /// Extrinsics
+        /// </summary>
         public Extrinsic[] Extrinsics { get; set; }
+        
+        /// <summary>
+        /// Header
+        /// </summary>
         public Header Header { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Rpc/BlockData.cs b/Substrate.NetApi/Model/Rpc/BlockData.cs
index ad4a229..8b642b4 100644
--- a/Substrate.NetApi/Model/Rpc/BlockData.cs
+++ b/Substrate.NetApi/Model/Rpc/BlockData.cs
@@ -2,17 +2,33 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Block Data
+    /// </summary>
     public class BlockData
     {
+        /// <summary>
+        /// Block Data Constructor
+        /// </summary>
+        /// <param name="block"></param>
+        /// <param name="justification"></param>
         public BlockData(Block block, object justification)
         {
             Block = block;
             Justification = justification;
         }
 
+        /// <summary>
+        /// Block
+        /// </summary>
         public Block Block { get; set; }
+        
+        /// <summary>
+        /// Justification
+        /// </summary>
         public object Justification { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/Digest.cs b/Substrate.NetApi/Model/Rpc/Digest.cs
index 46cf6bb..ba5f918 100644
--- a/Substrate.NetApi/Model/Rpc/Digest.cs
+++ b/Substrate.NetApi/Model/Rpc/Digest.cs
@@ -2,8 +2,14 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Digest
+    /// </summary>
     public class Digest
     {
+        /// <summary>
+        /// Logs
+        /// </summary>
         public IList<string> Logs { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Rpc/ExtrinsicStatus.cs b/Substrate.NetApi/Model/Rpc/ExtrinsicStatus.cs
index 4db6061..bde3bdf 100644
--- a/Substrate.NetApi/Model/Rpc/ExtrinsicStatus.cs
+++ b/Substrate.NetApi/Model/Rpc/ExtrinsicStatus.cs
@@ -4,21 +4,83 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Extrinsic State
+    /// </summary>
     public enum ExtrinsicState
     {
-        Future, Ready, Broadcast, InBlock, Retracted, FinalityTimeout, Finalized, Usurped, Dropped, Invalid
+        /// <summary>
+        /// Future
+        /// </summary>
+        Future, 
+        
+        /// <summary>
+        /// Ready
+        /// </summary>
+        Ready, 
+        
+        /// <summary>
+        /// Broadcast
+        /// </summary>
+        Broadcast, 
+        
+        /// <summary>
+        /// InBlock
+        /// </summary>
+        InBlock, 
+        
+        /// <summary>
+        /// Retracted
+        /// </summary>
+        Retracted, 
+        
+        /// <summary>
+        /// FinalityTimeout
+        /// </summary>
+        FinalityTimeout, 
+        
+        /// <summary>
+        /// Finalized
+        /// </summary>
+        Finalized, 
+        
+        /// <summary>
+        /// Usurped
+        /// </summary>
+        Usurped, 
+        
+        /// <summary>
+        /// Dropped
+        /// </summary>
+        Dropped, 
+        
+        /// <summary>
+        /// Invalid
+        /// </summary>
+        Invalid
     }
 
+    /// <summary>
+    /// Extrinsic Status
+    /// </summary>
     public class ExtrinsicStatus
     {
+        /// <summary>
+        /// Extrinsic State
+        /// </summary>
         public ExtrinsicState ExtrinsicState { get; set; }
         
+        /// <summary>
+        /// Broadcast
+        /// </summary>
         public string[] Broadcast { get; set; }
         
+        /// <summary>
+        /// Hash
+        /// </summary>
         public Hash Hash { get; set; }
 
-        //public ulong? TxIndex { get; set; }
-
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/FeeDetails.cs b/Substrate.NetApi/Model/Rpc/FeeDetails.cs
index b766cde..326a7d0 100644
--- a/Substrate.NetApi/Model/Rpc/FeeDetails.cs
+++ b/Substrate.NetApi/Model/Rpc/FeeDetails.cs
@@ -4,19 +4,37 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Fee Details
+    /// </summary>
     public class FeeDetails
     {
+        /// <summary>
+        /// Inclusion Fee
+        /// </summary>
         public InclusionFee InclusionFee { get; set; }
     }
 
+    /// <summary>
+    /// Inclusion Fee
+    /// </summary>
     public class InclusionFee
     {
+        /// <summary>
+        /// Base Fee
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<U128>))]
         public U128 BaseFee { get; set; }
 
+        /// <summary>
+        /// Len Fee
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<U128>))]
         public U128 LenFee { get; set; }
 
+        /// <summary>
+        /// Adjusted Weight Fee
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<U128>))]
         public U128 AdjustedWeightFee { get; set; }
     }
diff --git a/Substrate.NetApi/Model/Rpc/Header.cs b/Substrate.NetApi/Model/Rpc/Header.cs
index 8fb4160..fa657a2 100644
--- a/Substrate.NetApi/Model/Rpc/Header.cs
+++ b/Substrate.NetApi/Model/Rpc/Header.cs
@@ -5,22 +5,41 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Header
+    /// </summary>
     public class Header
     {
+        /// <summary>
+        /// Digest
+        /// </summary>
         public Digest Digest { get; set; }
 
+        /// <summary>
+        /// Extrinsics Root
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<Hash>))]
         public Hash ExtrinsicsRoot { get; set; }
 
+        /// <summary>
+        /// Number
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<U64>))]
         public U64 Number { get; set; }
 
+        /// <summary>
+        /// Parent Hash
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<Hash>))]
         public Hash ParentHash { get; set; }
 
+        /// <summary>
+        /// State Root
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<Hash>))]
         public Hash StateRoot { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/Health.cs b/Substrate.NetApi/Model/Rpc/Health.cs
index ce54faf..62ea7b3 100644
--- a/Substrate.NetApi/Model/Rpc/Health.cs
+++ b/Substrate.NetApi/Model/Rpc/Health.cs
@@ -2,12 +2,27 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Health
+    /// </summary>
     public class Health
     {
+        /// <summary>
+        /// Is Syncing
+        /// </summary>
         public bool IsSyncing { get; set; }
+        
+        /// <summary>
+        /// Peers
+        /// </summary>
         public int Peers { get; set; }
+        
+        /// <summary>
+        /// Should Have Peers
+        /// </summary>
         public bool ShouldHavePeers { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/Properties.cs b/Substrate.NetApi/Model/Rpc/Properties.cs
index cc7ace8..8c4c3bc 100644
--- a/Substrate.NetApi/Model/Rpc/Properties.cs
+++ b/Substrate.NetApi/Model/Rpc/Properties.cs
@@ -2,12 +2,27 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Properties
+    /// </summary>
     public class Properties
     {
+        /// <summary>
+        /// SS58 Format
+        /// </summary>
         public int Ss58Format { get; set; }
+        
+        /// <summary>
+        /// Token Decimals
+        /// </summary>
         public int TokenDecimals { get; set; }
+        
+        /// <summary>
+        /// Token Symbol
+        /// </summary>
         public string TokenSymbol { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/ReadProof.cs b/Substrate.NetApi/Model/Rpc/ReadProof.cs
index cd7c604..0b69154 100644
--- a/Substrate.NetApi/Model/Rpc/ReadProof.cs
+++ b/Substrate.NetApi/Model/Rpc/ReadProof.cs
@@ -4,12 +4,22 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Read Proof
+    /// </summary>
     public class ReadProof
     {
+        /// <summary>
+        /// At
+        /// </summary>
         public Hash At { get; set; }
 
+        /// <summary>
+        /// Proof
+        /// </summary>
         public IEnumerable<Hash> Proof { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/RuntimeDispatchInfo.cs b/Substrate.NetApi/Model/Rpc/RuntimeDispatchInfo.cs
index 22a4b8e..41ff166 100644
--- a/Substrate.NetApi/Model/Rpc/RuntimeDispatchInfo.cs
+++ b/Substrate.NetApi/Model/Rpc/RuntimeDispatchInfo.cs
@@ -1,15 +1,39 @@
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Runtime Dispatch Info
+    /// </summary>
     public class RuntimeDispatchInfo
     {
+        /// <summary>
+        /// Weight
+        /// </summary>
         public Weight Weight { get; set; }
+        
+        /// <summary>
+        /// Class
+        /// </summary>
         public string @Class { get; set; }
+        
+        /// <summary>
+        /// Partial Fee
+        /// </summary>
         public string PartialFee { get; set; }
     }
 
+    /// <summary>
+    /// Weight
+    /// </summary>
     public class Weight
     {
+        /// <summary>
+        /// Ref Time
+        /// </summary>
         public int Ref_time { get; set; }
+        
+        /// <summary>
+        /// Proof Size
+        /// </summary>
         public int Proof_size { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Rpc/RuntimeVersion.cs b/Substrate.NetApi/Model/Rpc/RuntimeVersion.cs
index 9eff90e..bc59b35 100644
--- a/Substrate.NetApi/Model/Rpc/RuntimeVersion.cs
+++ b/Substrate.NetApi/Model/Rpc/RuntimeVersion.cs
@@ -1,13 +1,43 @@
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Runtime Version
+    /// </summary>
     public class RuntimeVersion
     {
+        /// <summary>
+        /// Apis
+        /// </summary>
         public object[][] Apis { get; set; }
+        
+        /// <summary>
+        /// Authoring Version
+        /// </summary>
         public int AuthoringVersion { get; set; }
+        
+        /// <summary>
+        /// Impl Name
+        /// </summary>
         public string ImplName { get; set; }
+        
+        /// <summary>
+        /// Impl Version
+        /// </summary>
         public uint ImplVersion { get; set; }
+        
+        /// <summary>
+        /// Spec Name
+        /// </summary>
         public string SpecName { get; set; }
+        
+        /// <summary>
+        /// Spec Version
+        /// </summary>
         public uint SpecVersion { get; set; }
+        
+        /// <summary>
+        /// Transaction Version
+        /// </summary>
         public uint TransactionVersion { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Rpc/StorageChangeSet.cs b/Substrate.NetApi/Model/Rpc/StorageChangeSet.cs
index 90d34b1..ae32fc6 100644
--- a/Substrate.NetApi/Model/Rpc/StorageChangeSet.cs
+++ b/Substrate.NetApi/Model/Rpc/StorageChangeSet.cs
@@ -5,15 +5,23 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Storage Change Set
+    /// </summary>
     public class StorageChangeSet
     {
+        /// <summary>
+        /// Block Hash
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<Hash>))]
         public Hash Block { get; set; }
 
+        /// <summary>
+        /// Changes
+        /// </summary>
         public string[][] Changes { get; set; }
-        //[JsonConverter(typeof(GenericTypeConverter<Vec<RustTuple<StorageKey, StorageData>>>))]
-        //public Vec<RustTuple<StorageKey, StorageData>> Changes { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
@@ -30,25 +38,40 @@ public override string ToString()
     /// </summary>
     public class NewStorageChangeSet
     {
+        /// <summary>
+        /// Block Hash
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<Hash>))]
         public Hash Block { get; set; }
 
+        /// <summary>
+        /// Changes
+        /// </summary>
         [JsonConverter(typeof(GenericTypeConverter<BaseVec<BaseTuple<StorageKey, StorageData>>>))]
         public BaseVec<BaseTuple<StorageKey, StorageData>> Changes { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
         }
     }
 
+    /// <summary>
+    /// Storage Key
+    /// </summary>
     public class StorageKey : BaseVec<U8>
     {
+        /// <inheritdoc/>
         public override string TypeName() => "StorageKey";
     }
 
+    /// <summary>
+    /// Storage Data
+    /// </summary>
     public class StorageData : BaseVec<U8>
     {
+        /// <inheritdoc/>
         public override string TypeName() => "StorageData";
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Rpc/SyncState.cs b/Substrate.NetApi/Model/Rpc/SyncState.cs
index 25aca46..7d008de 100644
--- a/Substrate.NetApi/Model/Rpc/SyncState.cs
+++ b/Substrate.NetApi/Model/Rpc/SyncState.cs
@@ -2,12 +2,27 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Sync State
+    /// </summary>
     public class SyncState
     {
+        /// <summary>
+        /// Starting Block
+        /// </summary>
         public int StartingBlock { get; set; }
+        
+        /// <summary>
+        /// Current Block
+        /// </summary>
         public int CurrentBlock { get; set; }
+        
+        /// <summary>
+        /// Highest Block
+        /// </summary>
         public int HighestBlock { get; set; }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             return JsonConvert.SerializeObject(this);
diff --git a/Substrate.NetApi/Model/Rpc/TransactionEventInfo.cs b/Substrate.NetApi/Model/Rpc/TransactionEventInfo.cs
index 4f00f92..eade048 100644
--- a/Substrate.NetApi/Model/Rpc/TransactionEventInfo.cs
+++ b/Substrate.NetApi/Model/Rpc/TransactionEventInfo.cs
@@ -2,25 +2,55 @@
 
 namespace Substrate.NetApi.Model.Rpc
 {
+    /// <summary>
+    /// Transaction Event
+    /// </summary>
     public enum TransactionEvent
     {
+        /// <summary>
+        /// The validated event indicates that this transaction has been checked and is considered as valid by the runtime.
+        /// </summary>
         Validated,
 
+        /// <summary>
+        /// The broadcasted event indicates the number of other peers this transaction has been broadcasted to.
+        /// </summary>
         Broadcasted,
 
+        /// <summary>
+        /// The bestChainBlockIncluded event indicates which block of the best chain the transaction is included in.
+        /// </summary>
         BestChainBlockIncluded,
 
+        /// <summary>
+        /// The finalized event indicates that this transaction is present in a block of the chain that is finalized.
+        /// </summary>
         Finalized,
 
+        /// <summary>
+        /// The error event indicates that an internal error within the client has happened.
+        /// </summary>
         Error,
 
+        /// <summary>
+        /// The invalid event indicates that the runtime has marked the transaction as invalid.
+        /// </summary>
         Invalid,
 
+        /// <summary>
+        /// The dropped event indicates that the client wasn't capable of keeping track of this transaction.
+        /// </summary>
         Dropped
     }
 
+    /// <summary>
+    /// Transaction Event Info
+    /// </summary>
     public sealed class TransactionEventInfo
     {
+        /// <summary>   
+        /// Transaction Event
+        /// </summary>
         public TransactionEvent TransactionEvent { get; set; }
 
         /// <summary>
@@ -34,6 +64,9 @@ public sealed class TransactionEventInfo
         /// </summary>
         public Hash Hash { get; set; }
 
+        /// <summary>
+        /// Index is an integer indicating the 0-based index of this transaction within the body of this block.
+        /// </summary>
         public uint? Index { get; set; }
 
         /// <summary>
diff --git a/Substrate.NetApi/Model/Types/Account.cs b/Substrate.NetApi/Model/Types/Account.cs
index 4d316a4..a08a67d 100644
--- a/Substrate.NetApi/Model/Types/Account.cs
+++ b/Substrate.NetApi/Model/Types/Account.cs
@@ -12,7 +12,14 @@ namespace Substrate.NetApi.Model.Types
     /// </summary>
     public enum KeyType
     {
+        /// <summary>
+        /// Ed25519
+        /// </summary>
         Ed25519,
+
+        /// <summary>
+        /// Sr25519
+        /// </summary>
         Sr25519
     }
 
@@ -21,8 +28,20 @@ public enum KeyType
     /// </summary>
     public interface IAccount
     {
+        /// <summary>
+        /// Sign the specified message.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
         byte[] Sign(byte[] message);
 
+        /// <summary>
+        /// Verifies a signature from this account.
+        /// </summary>
+        /// <param name="signature"></param>
+        /// <param name="publicKey"></param>
+        /// <param name="message"></param>
+        /// <returns></returns>
         bool Verify(byte[] signature, byte[] publicKey, byte[] message);
     }
 
@@ -31,8 +50,14 @@ public interface IAccount
     /// </summary>
     public class Account : AccountId, IAccount
     {
+        /// <summary>
+        /// Key Type
+        /// </summary>
         public KeyType KeyType { get; private set; }
 
+        /// <summary>
+        /// Key Type Byte
+        /// </summary>
         [JsonIgnore]
         public byte KeyTypeByte
         {
@@ -52,7 +77,11 @@ public byte KeyTypeByte
             }
         }
 
-        [JsonIgnore] public byte[] PrivateKey { get; private set; }
+        /// <summary>
+        /// Private Key
+        /// </summary>
+        [JsonIgnore] 
+        public byte[] PrivateKey { get; private set; }
 
         /// <summary>
         /// Creates the specified key type with private key.
diff --git a/Substrate.NetApi/Model/Types/Base/AccountId.cs b/Substrate.NetApi/Model/Types/Base/AccountId.cs
index 0574bed..83922f3 100644
--- a/Substrate.NetApi/Model/Types/Base/AccountId.cs
+++ b/Substrate.NetApi/Model/Types/Base/AccountId.cs
@@ -3,27 +3,42 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Account Id
+    /// </summary>
     public class AccountId : BasePrim<string>
     {
+        /// <summary>
+        /// Account Id Constructor
+        /// </summary>
         public AccountId()
         { }
 
+        /// <summary>
+        /// Account Id Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public AccountId(string value)
         {
             Create(value);
         }
 
+        /// <summary>
+        /// Account Id Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public AccountId(byte[] value)
         {
             Create(value);
         }
 
-        // TODO: <T::Lookup as StaticLookup>::Source -- RawAccountId is unprefixed Address
+        /// <inheritdoc/>
         public override string TypeName() => "T::AccountId";
 
-        // TODO: might have to change this based on the address type.
+        /// <inheritdoc/>
         public override int TypeSize => 32;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var bytes = new List<byte>();
@@ -47,12 +62,14 @@ public override byte[] Encode()
             }
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = Utils.GetAddressFrom(byteArray);
         }
 
+        /// <inheritdoc/>
         public override void Create(string value) => Create(Utils.HexToByteArray(value));
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseBitSeq.cs b/Substrate.NetApi/Model/Types/Base/BaseBitSeq.cs
index 4246302..baad423 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseBitSeq.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseBitSeq.cs
@@ -14,13 +14,27 @@ public class BaseBitSeq<T1, T2> : IType
         where T1 : IType, new()
         where T2 : IType, new()
     {
+        /// <summary>
+        /// Type Name
+        /// </summary>
+        /// <returns></returns>
         public virtual string TypeName() => $"BitSequence<{new T1().TypeName()},{new T2().TypeName()}>";
 
+        /// <summary>
+        /// Type Size
+        /// </summary>
         public int TypeSize { get; set; }
 
+        /// <summary>
+        /// Bytes
+        /// </summary>
         [JsonIgnore]
         public byte[] Bytes { get; internal set; }
 
+        /// <summary>
+        /// Encode to Bytes
+        /// </summary>
+        /// <returns></returns>
         public byte[] Encode()
         {
             var result = new List<byte>
@@ -34,6 +48,11 @@ public byte[] Encode()
             return result.ToArray();
         }
 
+        /// <summary>
+        /// Decode from a byte array at certain position
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -57,8 +76,15 @@ public void Decode(byte[] byteArray, ref int p)
             Value = array;
         }
 
+        /// <summary>
+        /// Value
+        /// </summary>
         public virtual T1[] Value { get; internal set; }
 
+        /// <summary>
+        /// Create from a string
+        /// </summary>
+        /// <param name="list"></param>
         public void Create(T1[] list)
         {
             Value = list;
@@ -66,20 +92,42 @@ public void Create(T1[] list)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Create from a string
+        /// </summary>
+        /// <param name="str"></param>
         public void Create(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// Create from a json string
+        /// </summary>
+        /// <param name="str"></param>
         public void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// Create from a byte array
+        /// </summary>
+        /// <param name="byteArray"></param>
         public void Create(byte[] byteArray)
         {
             var p = 0;
             Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// New
+        /// </summary>
+        /// <returns></returns>
         public IType New() => this;
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(this);
 
+        /// <summary>
+        /// Reverse
+        /// </summary>
+        /// <param name="b"></param>
+        /// <returns></returns>
         public byte[] Reverse(byte[] b)
         {
             byte[] p = new byte[b.Length];
@@ -90,6 +138,11 @@ public byte[] Reverse(byte[] b)
             return p;
         }
 
+        /// <summary>
+        /// Reverse
+        /// </summary>
+        /// <param name="b"></param>
+        /// <returns></returns>
         public byte Reverse(byte b)
         {
             int a = 0;
diff --git a/Substrate.NetApi/Model/Types/Base/BaseCom.cs b/Substrate.NetApi/Model/Types/Base/BaseCom.cs
index 84e3a27..e97a2b3 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseCom.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseCom.cs
@@ -1,26 +1,48 @@
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// A compact type is a variable-length integer type that is encoded in a variable number of bytes depending on its value.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class BaseCom<T> : BaseType where T : IType, new()
     {
+        /// <summary>
+        /// Explicitly convert a CompactInteger to a BaseCom.
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator BaseCom<T>(CompactInteger p) => new BaseCom<T>(p);
 
+        /// <summary>
+        /// Implicitly convert a BaseCom to a CompactInteger.
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator CompactInteger(BaseCom<T> p) => p.Value;
 
+        /// <summary>
+        /// Construct a new BaseCom.
+        /// </summary>
         public BaseCom()
         { }
 
+        /// <summary>
+        /// Construct a new BaseCom.
+        /// </summary>
+        /// <param name="compactInteger"></param>
         public BaseCom(CompactInteger compactInteger)
         {
             Create(compactInteger);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => $"Compact<{new T().TypeName()}>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Value.Encode();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -30,8 +52,15 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Value
+        /// </summary>
         public virtual CompactInteger Value { get; internal set; }
 
+        /// <summary>
+        /// Create a new BaseCom.
+        /// </summary>
+        /// <param name="compactInteger"></param>
         public void Create(CompactInteger compactInteger)
         {
             Value = compactInteger;
diff --git a/Substrate.NetApi/Model/Types/Base/BaseEnum.cs b/Substrate.NetApi/Model/Types/Base/BaseEnum.cs
index 357ce8b..e0244d6 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseEnum.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseEnum.cs
@@ -4,32 +4,70 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base Enum Type
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class BaseEnum<T> : IType where T : System.Enum
     {
+        /// <summary>
+        /// Explicit conversion from T to BaseEnum
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator BaseEnum<T>(T p) => new BaseEnum<T>(p);
 
+        /// <summary>
+        /// Implicit conversion from BaseEnum to T
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator T(BaseEnum<T> p) => p.Value;
 
+        /// <summary>
+        /// BaseEnum Constructor
+        /// </summary>
         public BaseEnum()
         { }
 
+        /// <summary>
+        /// BaseEnum Constructor
+        /// </summary>
+        /// <param name="t"></param>
         public BaseEnum(T t)
         {
             Create(t);
         }
 
+        /// <summary>
+        /// BaseEnum Type Name
+        /// </summary>
+        /// <returns></returns>
         public string TypeName() => typeof(T).Name;
 
+        /// <summary>
+        /// BaseEnum Type Size
+        /// </summary>
         public int TypeSize { get; set; } = 1;
 
+        /// <summary>
+        /// Base Enum Bytes
+        /// </summary>
         [JsonIgnore]
         public byte[] Bytes { get; internal set; }
 
+        /// <summary>
+        /// Base Enum Encode
+        /// </summary>
+        /// <returns></returns>
         public byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <summary>
+        /// Base Enum Decode
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public void Decode(byte[] byteArray, ref int p)
         {
             var memory = byteArray.AsMemory();
@@ -38,26 +76,50 @@ public void Decode(byte[] byteArray, ref int p)
             Create(result);
         }
 
+        /// <summary>
+        /// Virtual Create
+        /// </summary>
+        /// <param name="str"></param>
         public virtual void Create(string str) => Create(Utils.HexToByteArray(str));
 
-        public virtual void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
-
+        /// <summary>
+        /// Create
+        /// </summary>
+        /// <param name="t"></param>
         public void Create(T t)
         {
             Bytes = new byte[1] { Convert.ToByte(t) };
             Value = t;
         }
 
+        /// <summary>
+        /// Create
+        /// </summary>
+        /// <param name="byteArray"></param>
         public void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = (T)Enum.Parse(typeof(T), byteArray[0].ToString(), true);
         }
 
+        /// <summary>
+        /// Virtual Create From Json
+        /// </summary>
+        /// <param name="str"></param>
+        public virtual void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
+
+        /// <summary>
+        /// New
+        /// </summary>
+        /// <returns></returns>
         public IType New() => this;
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// Base Enum Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T Value { get; internal set; }
     }
diff --git a/Substrate.NetApi/Model/Types/Base/BaseEnumExt.cs b/Substrate.NetApi/Model/Types/Base/BaseEnumExt.cs
index 47a6bc2..e54be78 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseEnumExt.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseEnumExt.cs
@@ -5,8 +5,18 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base Enum Extended Type
+    /// </summary>
     public abstract class BaseEnumType : BaseType
     {
+        /// <summary>
+        /// Decode Type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
+        /// <returns></returns>
         public static IType DecodeType<T>(byte[] byteArray, ref int p) where T : IType, new()
         {
             if (typeof(T) == typeof(BaseVoid))
@@ -17,17 +27,21 @@ public abstract class BaseEnumType : BaseType
         }
     }
 
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -44,6 +58,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -54,6 +71,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -65,26 +85,36 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
        where T2 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -101,6 +131,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -112,6 +145,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -123,27 +159,37 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
        where T2 : IType, new()
        where T3 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -160,6 +206,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -172,6 +221,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -183,14 +235,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -198,13 +257,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4> : BaseEnumType
        where T3 : IType, new()
        where T4 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -221,6 +283,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -234,6 +299,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -245,14 +313,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -261,13 +336,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5> : BaseEnumType
        where T4 : IType, new()
        where T5 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -284,6 +362,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -298,6 +379,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -309,14 +393,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -326,13 +417,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6> : BaseEnumType
        where T5 : IType, new()
        where T6 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -349,6 +443,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -364,6 +461,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -375,14 +475,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -393,13 +500,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7> : BaseEnumType
        where T6 : IType, new()
        where T7 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -416,6 +526,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -432,6 +545,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -443,14 +559,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -462,13 +585,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8> : BaseEnumType
        where T7 : IType, new()
        where T8 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -485,6 +611,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -502,6 +631,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -513,14 +645,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -533,13 +672,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> : BaseEnumType
        where T8 : IType, new()
        where T9 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -556,6 +698,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -574,6 +719,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -585,14 +733,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -606,13 +761,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : BaseEnum
        where T9 : IType, new()
        where T10 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -629,6 +787,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -648,6 +809,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -659,14 +823,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -681,13 +852,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : Bas
        where T10 : IType, new()
        where T11 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -704,6 +878,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -724,6 +901,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -735,14 +915,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -758,13 +945,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
        where T11 : IType, new()
        where T12 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -781,6 +971,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -802,6 +995,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -813,14 +1009,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -837,13 +1040,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T12 : IType, new()
        where T13 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -860,6 +1066,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -882,6 +1091,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -893,14 +1105,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -918,13 +1137,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T13 : IType, new()
        where T14 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -941,6 +1163,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -964,6 +1189,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -975,14 +1203,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1001,13 +1236,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T14 : IType, new()
        where T15 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1024,6 +1262,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1048,6 +1289,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1059,14 +1303,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1086,13 +1337,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T15 : IType, new()
        where T16 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1109,6 +1363,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1134,6 +1391,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1145,14 +1405,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1173,13 +1440,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T16 : IType, new()
        where T17 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1196,6 +1466,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1222,6 +1495,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1233,14 +1509,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1262,13 +1545,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T17 : IType, new()
        where T18 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1285,6 +1571,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1312,6 +1601,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1323,14 +1615,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1353,13 +1652,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T18 : IType, new()
        where T19 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1376,6 +1678,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1404,6 +1709,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1415,14 +1723,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1446,13 +1761,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T19 : IType, new()
        where T20 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1469,6 +1787,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1498,6 +1819,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1509,14 +1833,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1541,13 +1872,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T20 : IType, new()
        where T21 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1564,6 +1898,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1594,6 +1931,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1605,14 +1945,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1638,13 +1985,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T21 : IType, new()
        where T22 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1661,6 +2011,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1692,6 +2045,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1703,14 +2059,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1737,13 +2100,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T22 : IType, new()
        where T23 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1760,6 +2126,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1792,6 +2161,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1803,14 +2175,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1838,13 +2217,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T23 : IType, new()
        where T24 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1861,6 +2243,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1894,6 +2279,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1905,14 +2293,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1941,13 +2336,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T24 : IType, new()
        where T25 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1964,6 +2362,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1998,6 +2399,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2009,14 +2413,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2046,13 +2457,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T25 : IType, new()
        where T26 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2069,6 +2483,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2104,6 +2521,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2115,14 +2535,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2153,13 +2580,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T26 : IType, new()
        where T27 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2176,6 +2606,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2212,6 +2645,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2223,14 +2659,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2262,13 +2705,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T27 : IType, new()
        where T28 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2285,6 +2731,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2322,6 +2771,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2333,14 +2785,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2373,13 +2832,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T28 : IType, new()
        where T29 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2396,6 +2858,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2434,6 +2899,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2445,14 +2913,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2486,13 +2961,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T29 : IType, new()
        where T30 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2509,6 +2987,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2548,6 +3029,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2559,14 +3043,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2601,13 +3092,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T30 : IType, new()
        where T31 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2624,6 +3118,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2664,6 +3161,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2675,14 +3175,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2718,13 +3225,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T31 : IType, new()
        where T32 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2741,6 +3251,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2782,6 +3295,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2793,14 +3309,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2837,13 +3360,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T32 : IType, new()
        where T33 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2860,6 +3386,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2902,6 +3431,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2913,14 +3445,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2958,13 +3497,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T33 : IType, new()
        where T34 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2981,6 +3523,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3024,6 +3569,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3035,14 +3583,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3081,13 +3636,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T34 : IType, new()
        where T35 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3104,6 +3662,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3148,6 +3709,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3159,14 +3723,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3206,13 +3777,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T35 : IType, new()
        where T36 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3229,6 +3803,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3274,6 +3851,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3285,14 +3865,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3333,13 +3920,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T36 : IType, new()
        where T37 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3356,6 +3946,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3402,6 +3995,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3413,14 +4009,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3462,13 +4065,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T37 : IType, new()
        where T38 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3485,6 +4091,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3532,6 +4141,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3543,14 +4155,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3593,13 +4212,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T38 : IType, new()
        where T39 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3616,6 +4238,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3664,6 +4289,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3675,14 +4303,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3726,13 +4361,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T39 : IType, new()
        where T40 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3749,6 +4387,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3798,6 +4439,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3809,14 +4453,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3861,13 +4512,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T40 : IType, new()
        where T41 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3884,6 +4538,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3934,6 +4591,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3945,14 +4605,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3998,13 +4665,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T41 : IType, new()
        where T42 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4021,6 +4691,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4072,6 +4745,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4083,14 +4759,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4137,13 +4820,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T42 : IType, new()
        where T43 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4160,6 +4846,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4212,6 +4901,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4223,14 +4915,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4278,13 +4977,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T43 : IType, new()
        where T44 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4301,6 +5003,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4354,6 +5059,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4365,14 +5073,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4421,13 +5136,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T44 : IType, new()
        where T45 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4444,6 +5162,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4498,6 +5219,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4509,14 +5233,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4566,13 +5297,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T45 : IType, new()
        where T46 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4589,6 +5323,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4644,6 +5381,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4655,14 +5395,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4713,13 +5460,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T46 : IType, new()
        where T47 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4736,6 +5486,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4792,6 +5545,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4803,14 +5559,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4862,13 +5625,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T47 : IType, new()
        where T48 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4885,6 +5651,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4942,6 +5711,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4953,14 +5725,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5013,13 +5792,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T48 : IType, new()
        where T49 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5036,6 +5818,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5094,6 +5879,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5105,14 +5893,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5166,13 +5961,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T49 : IType, new()
        where T50 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5189,6 +5987,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5248,6 +6049,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5259,14 +6063,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5321,13 +6132,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T50 : IType, new()
        where T51 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5344,6 +6158,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5404,6 +6221,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5415,14 +6235,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5478,13 +6305,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T51 : IType, new()
        where T52 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5501,6 +6331,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5562,6 +6395,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5573,14 +6409,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5637,13 +6480,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T52 : IType, new()
        where T53 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5660,6 +6506,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5722,6 +6571,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5733,14 +6585,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5798,13 +6657,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T53 : IType, new()
        where T54 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5821,6 +6683,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5884,6 +6749,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5895,14 +6763,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5961,13 +6836,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T54 : IType, new()
        where T55 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5984,6 +6862,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6048,6 +6929,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6059,14 +6943,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6126,13 +7017,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T55 : IType, new()
        where T56 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6149,6 +7043,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6214,6 +7111,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6225,14 +7125,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6293,13 +7200,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T56 : IType, new()
        where T57 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6316,6 +7226,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6382,6 +7295,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6393,14 +7309,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6462,13 +7385,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T57 : IType, new()
        where T58 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6485,6 +7411,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6552,6 +7481,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6563,14 +7495,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6633,13 +7572,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T58 : IType, new()
        where T59 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6656,6 +7598,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6724,6 +7669,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6735,14 +7683,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6806,13 +7761,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T59 : IType, new()
        where T60 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6829,6 +7787,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6898,6 +7859,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6909,14 +7873,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6981,13 +7952,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T60 : IType, new()
        where T61 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7004,6 +7978,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7074,6 +8051,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7085,14 +8065,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7158,13 +8145,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T61 : IType, new()
        where T62 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7181,6 +8171,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7252,6 +8245,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7263,14 +8259,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7337,13 +8340,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T62 : IType, new()
        where T63 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7360,6 +8366,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7432,6 +8441,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7443,14 +8455,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7518,13 +8537,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T63 : IType, new()
        where T64 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7541,6 +8563,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7614,6 +8639,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7625,14 +8653,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7701,13 +8736,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T64 : IType, new()
        where T65 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7724,6 +8762,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7798,6 +8839,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7809,14 +8853,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7886,13 +8937,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T65 : IType, new()
        where T66 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7909,6 +8963,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7984,6 +9041,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7995,14 +9055,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8073,13 +9140,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T66 : IType, new()
        where T67 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8096,6 +9166,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8172,6 +9245,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8183,14 +9259,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8262,13 +9345,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T67 : IType, new()
        where T68 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8285,6 +9371,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8362,6 +9451,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8373,14 +9465,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8453,13 +9552,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T68 : IType, new()
        where T69 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8476,6 +9578,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8554,6 +9659,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8565,14 +9673,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8646,13 +9761,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T69 : IType, new()
        where T70 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8669,6 +9787,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8748,6 +9869,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8759,14 +9883,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8841,13 +9972,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T70 : IType, new()
        where T71 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8864,6 +9998,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8944,6 +10081,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8955,14 +10095,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9038,13 +10185,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T71 : IType, new()
        where T72 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9061,6 +10211,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9142,6 +10295,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9153,14 +10309,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9237,13 +10400,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T72 : IType, new()
        where T73 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9260,6 +10426,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9342,6 +10511,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9353,14 +10525,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9438,13 +10617,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T73 : IType, new()
        where T74 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9461,6 +10643,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9544,6 +10729,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9555,14 +10743,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9641,13 +10836,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T74 : IType, new()
        where T75 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9664,6 +10862,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9748,6 +10949,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9759,14 +10963,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9846,13 +11057,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T75 : IType, new()
        where T76 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9869,6 +11083,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9954,6 +11171,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9965,14 +11185,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10053,13 +11280,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T76 : IType, new()
        where T77 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10076,6 +11306,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10162,6 +11395,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10173,14 +11409,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10262,13 +11505,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T77 : IType, new()
        where T78 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10285,6 +11531,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10372,6 +11621,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10383,14 +11635,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10473,13 +11732,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T78 : IType, new()
        where T79 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10496,6 +11758,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10584,6 +11849,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10595,14 +11863,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10686,13 +11961,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T79 : IType, new()
        where T80 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10709,6 +11987,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10798,6 +12079,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10809,14 +12093,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10901,13 +12192,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T80 : IType, new()
        where T81 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10924,6 +12218,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11014,6 +12311,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11025,14 +12325,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11118,13 +12425,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T81 : IType, new()
        where T82 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11141,6 +12451,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11232,6 +12545,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11243,14 +12559,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11337,13 +12660,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T82 : IType, new()
        where T83 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11360,6 +12686,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11452,6 +12781,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11463,14 +12795,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11558,13 +12897,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T83 : IType, new()
        where T84 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11581,6 +12923,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11674,6 +13019,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11685,14 +13033,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11781,13 +13136,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T84 : IType, new()
        where T85 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11804,6 +13162,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11898,6 +13259,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11909,14 +13273,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12006,13 +13377,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T85 : IType, new()
        where T86 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12029,6 +13403,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12124,6 +13501,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12135,14 +13515,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12233,13 +13620,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T86 : IType, new()
        where T87 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12256,6 +13646,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12352,6 +13745,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12363,14 +13759,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12462,13 +13865,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T87 : IType, new()
        where T88 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12485,6 +13891,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12582,6 +13991,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12593,14 +14005,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12693,13 +14112,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T88 : IType, new()
        where T89 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12716,6 +14138,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12814,6 +14239,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12825,14 +14253,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12926,13 +14361,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T89 : IType, new()
        where T90 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12949,6 +14387,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13048,6 +14489,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13059,14 +14503,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13161,13 +14612,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T90 : IType, new()
        where T91 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13184,6 +14638,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13284,6 +14741,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13295,14 +14755,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13398,13 +14865,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T91 : IType, new()
        where T92 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13421,6 +14891,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13522,6 +14995,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13533,14 +15009,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13637,13 +15120,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T92 : IType, new()
        where T93 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13660,6 +15146,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13762,6 +15251,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13773,14 +15265,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13878,13 +15377,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T93 : IType, new()
        where T94 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13901,6 +15403,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14004,6 +15509,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14015,14 +15523,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -14121,13 +15636,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T94 : IType, new()
        where T95 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -14144,6 +15662,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14248,6 +15769,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14259,14 +15783,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -14366,13 +15897,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T95 : IType, new()
        where T96 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -14389,6 +15923,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14494,6 +16031,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14505,14 +16045,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -14613,13 +16160,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T96 : IType, new()
        where T97 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -14636,6 +16186,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14742,6 +16295,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14753,14 +16309,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -14862,13 +16425,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T97 : IType, new()
        where T98 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -14885,6 +16451,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14992,6 +16561,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -15003,14 +16575,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -15113,13 +16692,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T98 : IType, new()
        where T99 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -15136,6 +16718,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -15244,6 +16829,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -15255,14 +16843,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -15366,13 +16961,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T99 : IType, new()
        where T100 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -15389,6 +16987,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -15498,6 +17099,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -15509,11 +17113,19 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseEnumExt2.cs b/Substrate.NetApi/Model/Types/Base/BaseEnumExt2.cs
index 5266db9..df7402d 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseEnumExt2.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseEnumExt2.cs
@@ -5,117 +5,122 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101> : BaseEnumType
-     where T0 : Enum
-     where T1 : IType, new()
-     where T2 : IType, new()
-     where T3 : IType, new()
-     where T4 : IType, new()
-     where T5 : IType, new()
-     where T6 : IType, new()
-     where T7 : IType, new()
-     where T8 : IType, new()
-     where T9 : IType, new()
-     where T10 : IType, new()
-     where T11 : IType, new()
-     where T12 : IType, new()
-     where T13 : IType, new()
-     where T14 : IType, new()
-     where T15 : IType, new()
-     where T16 : IType, new()
-     where T17 : IType, new()
-     where T18 : IType, new()
-     where T19 : IType, new()
-     where T20 : IType, new()
-     where T21 : IType, new()
-     where T22 : IType, new()
-     where T23 : IType, new()
-     where T24 : IType, new()
-     where T25 : IType, new()
-     where T26 : IType, new()
-     where T27 : IType, new()
-     where T28 : IType, new()
-     where T29 : IType, new()
-     where T30 : IType, new()
-     where T31 : IType, new()
-     where T32 : IType, new()
-     where T33 : IType, new()
-     where T34 : IType, new()
-     where T35 : IType, new()
-     where T36 : IType, new()
-     where T37 : IType, new()
-     where T38 : IType, new()
-     where T39 : IType, new()
-     where T40 : IType, new()
-     where T41 : IType, new()
-     where T42 : IType, new()
-     where T43 : IType, new()
-     where T44 : IType, new()
-     where T45 : IType, new()
-     where T46 : IType, new()
-     where T47 : IType, new()
-     where T48 : IType, new()
-     where T49 : IType, new()
-     where T50 : IType, new()
-     where T51 : IType, new()
-     where T52 : IType, new()
-     where T53 : IType, new()
-     where T54 : IType, new()
-     where T55 : IType, new()
-     where T56 : IType, new()
-     where T57 : IType, new()
-     where T58 : IType, new()
-     where T59 : IType, new()
-     where T60 : IType, new()
-     where T61 : IType, new()
-     where T62 : IType, new()
-     where T63 : IType, new()
-     where T64 : IType, new()
-     where T65 : IType, new()
-     where T66 : IType, new()
-     where T67 : IType, new()
-     where T68 : IType, new()
-     where T69 : IType, new()
-     where T70 : IType, new()
-     where T71 : IType, new()
-     where T72 : IType, new()
-     where T73 : IType, new()
-     where T74 : IType, new()
-     where T75 : IType, new()
-     where T76 : IType, new()
-     where T77 : IType, new()
-     where T78 : IType, new()
-     where T79 : IType, new()
-     where T80 : IType, new()
-     where T81 : IType, new()
-     where T82 : IType, new()
-     where T83 : IType, new()
-     where T84 : IType, new()
-     where T85 : IType, new()
-     where T86 : IType, new()
-     where T87 : IType, new()
-     where T88 : IType, new()
-     where T89 : IType, new()
-     where T90 : IType, new()
-     where T91 : IType, new()
-     where T92 : IType, new()
-     where T93 : IType, new()
-     where T94 : IType, new()
-     where T95 : IType, new()
-     where T96 : IType, new()
-     where T97 : IType, new()
-     where T98 : IType, new()
-     where T99 : IType, new()
-     where T100 : IType, new()
-     where T101 : IType, new()
+       where T0 : Enum
+       where T1 : IType, new()
+       where T2 : IType, new()
+       where T3 : IType, new()
+       where T4 : IType, new()
+       where T5 : IType, new()
+       where T6 : IType, new()
+       where T7 : IType, new()
+       where T8 : IType, new()
+       where T9 : IType, new()
+       where T10 : IType, new()
+       where T11 : IType, new()
+       where T12 : IType, new()
+       where T13 : IType, new()
+       where T14 : IType, new()
+       where T15 : IType, new()
+       where T16 : IType, new()
+       where T17 : IType, new()
+       where T18 : IType, new()
+       where T19 : IType, new()
+       where T20 : IType, new()
+       where T21 : IType, new()
+       where T22 : IType, new()
+       where T23 : IType, new()
+       where T24 : IType, new()
+       where T25 : IType, new()
+       where T26 : IType, new()
+       where T27 : IType, new()
+       where T28 : IType, new()
+       where T29 : IType, new()
+       where T30 : IType, new()
+       where T31 : IType, new()
+       where T32 : IType, new()
+       where T33 : IType, new()
+       where T34 : IType, new()
+       where T35 : IType, new()
+       where T36 : IType, new()
+       where T37 : IType, new()
+       where T38 : IType, new()
+       where T39 : IType, new()
+       where T40 : IType, new()
+       where T41 : IType, new()
+       where T42 : IType, new()
+       where T43 : IType, new()
+       where T44 : IType, new()
+       where T45 : IType, new()
+       where T46 : IType, new()
+       where T47 : IType, new()
+       where T48 : IType, new()
+       where T49 : IType, new()
+       where T50 : IType, new()
+       where T51 : IType, new()
+       where T52 : IType, new()
+       where T53 : IType, new()
+       where T54 : IType, new()
+       where T55 : IType, new()
+       where T56 : IType, new()
+       where T57 : IType, new()
+       where T58 : IType, new()
+       where T59 : IType, new()
+       where T60 : IType, new()
+       where T61 : IType, new()
+       where T62 : IType, new()
+       where T63 : IType, new()
+       where T64 : IType, new()
+       where T65 : IType, new()
+       where T66 : IType, new()
+       where T67 : IType, new()
+       where T68 : IType, new()
+       where T69 : IType, new()
+       where T70 : IType, new()
+       where T71 : IType, new()
+       where T72 : IType, new()
+       where T73 : IType, new()
+       where T74 : IType, new()
+       where T75 : IType, new()
+       where T76 : IType, new()
+       where T77 : IType, new()
+       where T78 : IType, new()
+       where T79 : IType, new()
+       where T80 : IType, new()
+       where T81 : IType, new()
+       where T82 : IType, new()
+       where T83 : IType, new()
+       where T84 : IType, new()
+       where T85 : IType, new()
+       where T86 : IType, new()
+       where T87 : IType, new()
+       where T88 : IType, new()
+       where T89 : IType, new()
+       where T90 : IType, new()
+       where T91 : IType, new()
+       where T92 : IType, new()
+       where T93 : IType, new()
+       where T94 : IType, new()
+       where T95 : IType, new()
+       where T96 : IType, new()
+       where T97 : IType, new()
+       where T98 : IType, new()
+       where T99 : IType, new()
+       where T100 : IType, new()
+       where T101 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -132,6 +137,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -242,6 +250,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -253,13 +264,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -365,13 +384,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T101 : IType, new()
        where T102 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -388,6 +410,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -499,6 +524,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -510,13 +538,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -623,13 +659,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T102 : IType, new()
        where T103 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -646,6 +685,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -758,6 +800,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -769,13 +814,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -883,13 +936,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T103 : IType, new()
        where T104 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -906,6 +962,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1019,6 +1078,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1030,13 +1092,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1145,13 +1215,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T104 : IType, new()
        where T105 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1168,6 +1241,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1282,6 +1358,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1293,13 +1372,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1409,13 +1496,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T105 : IType, new()
        where T106 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1432,6 +1522,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1547,6 +1640,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1558,13 +1654,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1675,13 +1779,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T106 : IType, new()
        where T107 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1698,6 +1805,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -1814,6 +1924,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -1825,13 +1938,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -1943,13 +2064,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T107 : IType, new()
        where T108 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1966,6 +2090,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2083,6 +2210,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2094,13 +2224,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2213,13 +2351,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T108 : IType, new()
        where T109 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2236,6 +2377,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2354,6 +2498,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2365,13 +2512,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2485,13 +2640,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T109 : IType, new()
        where T110 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2508,6 +2666,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2627,6 +2788,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2638,13 +2802,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -2759,13 +2931,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T110 : IType, new()
        where T111 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2782,6 +2957,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -2902,6 +3080,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -2913,13 +3094,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3035,13 +3224,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T111 : IType, new()
        where T112 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3058,6 +3250,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3179,6 +3374,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3190,13 +3388,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3313,13 +3519,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T112 : IType, new()
        where T113 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3336,6 +3545,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3458,6 +3670,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3469,13 +3684,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3593,13 +3816,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T113 : IType, new()
        where T114 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3616,6 +3842,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -3739,6 +3968,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -3750,13 +3982,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -3875,13 +4115,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T114 : IType, new()
        where T115 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3898,6 +4141,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4022,6 +4268,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4033,13 +4282,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4159,13 +4416,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T115 : IType, new()
        where T116 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4182,6 +4442,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4307,6 +4570,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4318,13 +4584,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4445,13 +4719,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T116 : IType, new()
        where T117 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4468,6 +4745,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4594,6 +4874,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4605,13 +4888,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -4733,13 +5024,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T117 : IType, new()
        where T118 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4756,6 +5050,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -4883,6 +5180,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -4894,13 +5194,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5023,13 +5331,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T118 : IType, new()
        where T119 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5046,6 +5357,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5174,6 +5488,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5185,13 +5502,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5315,13 +5640,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T119 : IType, new()
        where T120 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5338,6 +5666,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5467,6 +5798,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5478,13 +5812,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5609,13 +5951,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T120 : IType, new()
        where T121 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5632,6 +5977,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -5762,6 +6110,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -5773,13 +6124,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -5905,13 +6264,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T121 : IType, new()
        where T122 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5928,6 +6290,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6059,6 +6424,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6070,13 +6438,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6203,13 +6579,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T122 : IType, new()
        where T123 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6226,6 +6605,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6358,6 +6740,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6369,13 +6754,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6503,13 +6896,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T123 : IType, new()
        where T124 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6526,6 +6922,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6659,6 +7058,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6670,13 +7072,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -6805,13 +7215,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T124 : IType, new()
        where T125 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6828,6 +7241,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -6962,6 +7378,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -6973,13 +7392,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7109,13 +7536,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T125 : IType, new()
        where T126 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7132,6 +7562,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7267,6 +7700,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7278,13 +7714,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7415,13 +7859,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T126 : IType, new()
        where T127 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7438,6 +7885,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7574,6 +8024,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7585,13 +8038,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -7723,13 +8184,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T127 : IType, new()
        where T128 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7746,6 +8210,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -7883,6 +8350,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -7894,13 +8364,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8033,13 +8511,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T128 : IType, new()
        where T129 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8056,6 +8537,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8194,6 +8678,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8205,13 +8692,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8345,13 +8840,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T129 : IType, new()
        where T130 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8368,6 +8866,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8507,6 +9008,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8518,13 +9022,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8659,13 +9171,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T130 : IType, new()
        where T131 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8682,6 +9197,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -8822,6 +9340,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -8833,13 +9354,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -8975,13 +9504,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T131 : IType, new()
        where T132 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -8998,6 +9530,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9139,6 +9674,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9150,13 +9688,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9293,13 +9839,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T132 : IType, new()
        where T133 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9316,6 +9865,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9458,6 +10010,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9469,13 +10024,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9613,13 +10176,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T133 : IType, new()
        where T134 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9636,6 +10202,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -9779,6 +10348,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -9790,13 +10362,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -9935,13 +10515,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T134 : IType, new()
        where T135 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -9958,6 +10541,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10102,6 +10688,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10113,13 +10702,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10259,13 +10856,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T135 : IType, new()
        where T136 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10282,6 +10882,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10427,6 +11030,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10438,13 +11044,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10585,13 +11199,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T136 : IType, new()
        where T137 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10608,6 +11225,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -10754,6 +11374,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -10765,13 +11388,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -10913,13 +11544,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T137 : IType, new()
        where T138 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -10936,6 +11570,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11083,6 +11720,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11094,13 +11734,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11243,13 +11891,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T138 : IType, new()
        where T139 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11266,6 +11917,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11414,6 +12068,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11425,13 +12082,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11575,13 +12240,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T139 : IType, new()
        where T140 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11598,6 +12266,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -11747,6 +12418,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -11758,13 +12432,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -11909,13 +12591,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T140 : IType, new()
        where T141 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -11932,6 +12617,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12082,6 +12770,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12093,13 +12784,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12245,13 +12944,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T141 : IType, new()
        where T142 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12268,6 +12970,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12419,6 +13124,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12430,13 +13138,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12583,13 +13299,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T142 : IType, new()
        where T143 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12606,6 +13325,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -12758,6 +13480,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -12769,13 +13494,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -12923,13 +13656,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T143 : IType, new()
        where T144 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -12946,6 +13682,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13099,6 +13838,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13110,13 +13852,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13265,13 +14015,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T144 : IType, new()
        where T145 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13288,6 +14041,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13442,6 +14198,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13453,13 +14212,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13609,13 +14376,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T145 : IType, new()
        where T146 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13632,6 +14402,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -13787,6 +14560,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -13798,13 +14574,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -13955,13 +14739,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T146 : IType, new()
        where T147 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -13978,6 +14765,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14134,6 +14924,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14145,13 +14938,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -14303,13 +15104,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T147 : IType, new()
        where T148 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -14326,6 +15130,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14483,6 +15290,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14494,13 +15304,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -14653,13 +15471,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T148 : IType, new()
        where T149 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -14676,6 +15497,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -14834,6 +15658,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -14845,13 +15672,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -15005,13 +15840,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T149 : IType, new()
        where T150 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -15028,6 +15866,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -15187,6 +16028,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -15198,13 +16042,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -15359,13 +16211,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T150 : IType, new()
        where T151 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -15382,6 +16237,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -15542,6 +16400,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -15553,13 +16414,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -15715,13 +16584,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T151 : IType, new()
        where T152 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -15738,6 +16610,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -15899,6 +16774,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -15910,13 +16788,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -16073,13 +16959,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T152 : IType, new()
        where T153 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -16096,6 +16985,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -16258,6 +17150,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -16269,13 +17164,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -16433,13 +17336,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T153 : IType, new()
        where T154 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -16456,6 +17362,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -16619,6 +17528,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -16630,13 +17542,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -16795,13 +17715,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T154 : IType, new()
        where T155 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -16818,6 +17741,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -16982,6 +17908,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -16993,13 +17922,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -17159,13 +18096,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T155 : IType, new()
        where T156 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -17182,6 +18122,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -17347,6 +18290,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -17358,13 +18304,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -17525,13 +18479,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T156 : IType, new()
        where T157 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -17548,6 +18505,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -17714,6 +18674,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -17725,13 +18688,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -17893,13 +18864,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T157 : IType, new()
        where T158 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -17916,6 +18890,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -18083,6 +19060,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -18094,13 +19074,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -18263,13 +19251,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T158 : IType, new()
        where T159 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -18286,6 +19277,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -18454,6 +19448,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -18465,13 +19462,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -18635,13 +19640,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T159 : IType, new()
        where T160 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -18658,6 +19666,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -18827,6 +19838,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -18838,13 +19852,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -19009,13 +20031,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T160 : IType, new()
        where T161 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -19032,6 +20057,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -19202,6 +20230,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -19213,13 +20244,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -19385,13 +20424,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T161 : IType, new()
        where T162 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -19408,6 +20450,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -19579,6 +20624,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -19590,13 +20638,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -19763,13 +20819,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T162 : IType, new()
        where T163 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -19786,6 +20845,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -19958,6 +21020,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -19969,13 +21034,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -20143,13 +21216,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T163 : IType, new()
        where T164 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -20166,6 +21242,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -20339,6 +21418,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -20350,13 +21432,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -20525,13 +21615,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T164 : IType, new()
        where T165 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -20548,6 +21641,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -20722,6 +21818,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -20733,13 +21832,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -20909,13 +22016,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T165 : IType, new()
        where T166 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -20932,6 +22042,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -21107,6 +22220,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -21118,13 +22234,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -21295,13 +22419,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T166 : IType, new()
        where T167 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -21318,6 +22445,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -21494,6 +22624,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -21505,13 +22638,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -21683,13 +22824,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T167 : IType, new()
        where T168 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -21706,6 +22850,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -21883,6 +23030,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -21894,13 +23044,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -22073,13 +23231,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T168 : IType, new()
        where T169 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -22096,6 +23257,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -22274,6 +23438,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -22285,13 +23452,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -22465,13 +23640,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T169 : IType, new()
        where T170 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -22488,6 +23666,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -22667,6 +23848,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -22678,13 +23862,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -22859,13 +24051,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T170 : IType, new()
        where T171 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -22882,6 +24077,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -23062,6 +24260,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -23073,13 +24274,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -23255,13 +24464,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T171 : IType, new()
        where T172 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -23278,6 +24490,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -23459,6 +24674,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -23470,13 +24688,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -23653,13 +24879,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T172 : IType, new()
        where T173 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -23676,6 +24905,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -23858,6 +25090,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -23869,13 +25104,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -24053,13 +25296,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T173 : IType, new()
        where T174 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -24076,6 +25322,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -24259,6 +25508,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -24270,13 +25522,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -24455,13 +25715,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T174 : IType, new()
        where T175 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -24478,6 +25741,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -24662,6 +25928,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -24673,13 +25942,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -24859,13 +26136,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T175 : IType, new()
        where T176 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -24882,6 +26162,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -25067,6 +26350,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -25078,13 +26364,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -25265,13 +26559,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T176 : IType, new()
        where T177 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -25288,6 +26585,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -25474,6 +26774,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -25485,13 +26788,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -25673,13 +26984,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T177 : IType, new()
        where T178 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -25696,6 +27010,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -25883,6 +27200,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -25894,13 +27214,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -26083,13 +27411,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T178 : IType, new()
        where T179 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -26106,6 +27437,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -26294,6 +27628,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -26305,13 +27642,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -26495,13 +27840,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T179 : IType, new()
        where T180 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -26518,6 +27866,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -26707,6 +28058,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -26718,13 +28072,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -26909,13 +28271,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T180 : IType, new()
        where T181 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -26932,6 +28297,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -27122,6 +28490,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -27133,13 +28504,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -27325,13 +28704,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T181 : IType, new()
        where T182 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -27348,6 +28730,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -27539,6 +28924,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -27550,13 +28938,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -27743,13 +29139,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T182 : IType, new()
        where T183 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -27766,6 +29165,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -27958,6 +29360,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -27969,13 +29374,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -28163,13 +29576,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T183 : IType, new()
        where T184 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -28186,6 +29602,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -28379,6 +29798,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -28390,13 +29812,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -28585,13 +30015,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T184 : IType, new()
        where T185 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -28608,6 +30041,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -28802,6 +30238,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -28813,13 +30252,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -29009,13 +30456,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T185 : IType, new()
        where T186 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -29032,6 +30482,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -29227,6 +30680,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -29238,13 +30694,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -29435,13 +30899,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T186 : IType, new()
        where T187 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -29458,6 +30925,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -29654,6 +31124,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -29665,13 +31138,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -29863,13 +31344,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T187 : IType, new()
        where T188 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -29886,6 +31370,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -30083,6 +31570,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -30094,13 +31584,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -30293,13 +31791,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T188 : IType, new()
        where T189 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -30316,6 +31817,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -30514,6 +32018,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -30525,13 +32032,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -30725,13 +32240,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T189 : IType, new()
        where T190 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -30748,6 +32266,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -30947,6 +32468,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -30958,13 +32482,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -31159,13 +32691,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T190 : IType, new()
        where T191 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -31182,6 +32717,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -31382,6 +32920,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -31393,13 +32934,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -31595,13 +33144,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T191 : IType, new()
        where T192 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -31618,6 +33170,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -31819,6 +33374,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -31830,13 +33388,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -32033,13 +33599,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T192 : IType, new()
        where T193 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32056,6 +33625,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -32258,6 +33830,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -32269,13 +33844,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -32473,13 +34056,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T193 : IType, new()
        where T194 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32496,6 +34082,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -32699,6 +34288,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -32710,13 +34302,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -32915,13 +34515,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T194 : IType, new()
        where T195 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32938,6 +34541,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -33142,6 +34748,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -33153,13 +34762,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -33359,13 +34976,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T195 : IType, new()
        where T196 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -33382,6 +35002,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -33587,6 +35210,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -33598,13 +35224,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -33805,13 +35439,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T196 : IType, new()
        where T197 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -33828,6 +35465,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -34034,6 +35674,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -34045,13 +35688,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -34253,13 +35904,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T197 : IType, new()
        where T198 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -34276,6 +35930,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -34483,6 +36140,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -34494,13 +36154,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -34703,13 +36371,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T198 : IType, new()
        where T199 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -34726,6 +36397,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -34934,6 +36608,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -34945,13 +36622,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -35155,13 +36840,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T199 : IType, new()
        where T200 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -35178,6 +36866,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -35387,6 +37078,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -35398,13 +37092,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -35609,13 +37311,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T200 : IType, new()
        where T201 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -35632,6 +37337,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -35842,6 +37550,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -35853,13 +37564,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -36065,13 +37784,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T201 : IType, new()
        where T202 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -36088,6 +37810,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -36299,6 +38024,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -36310,13 +38038,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -36523,13 +38259,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T202 : IType, new()
        where T203 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -36546,6 +38285,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -36758,6 +38500,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -36769,13 +38514,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -36983,13 +38736,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T203 : IType, new()
        where T204 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -37006,6 +38762,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -37219,6 +38978,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -37230,13 +38992,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -37445,13 +39215,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T204 : IType, new()
        where T205 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -37468,6 +39241,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -37682,6 +39458,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -37693,13 +39472,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -37909,13 +39696,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T205 : IType, new()
        where T206 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -37932,6 +39722,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -38147,6 +39940,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -38158,13 +39954,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -38375,13 +40179,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T206 : IType, new()
        where T207 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -38398,6 +40205,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -38614,6 +40424,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -38625,13 +40438,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -38843,13 +40664,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T207 : IType, new()
        where T208 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -38866,6 +40690,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -39083,6 +40910,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -39094,13 +40924,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -39313,13 +41151,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T208 : IType, new()
        where T209 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -39336,6 +41177,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -39554,6 +41398,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -39565,13 +41412,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -39785,13 +41640,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T209 : IType, new()
        where T210 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -39808,6 +41666,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -40027,6 +41888,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -40038,13 +41902,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -40259,13 +42131,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T210 : IType, new()
        where T211 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -40282,6 +42157,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -40502,6 +42380,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -40513,13 +42394,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -40735,13 +42624,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T211 : IType, new()
        where T212 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -40758,6 +42650,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -40979,6 +42874,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -40990,13 +42888,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -41213,13 +43119,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T212 : IType, new()
        where T213 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -41236,6 +43145,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -41458,6 +43370,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -41469,13 +43384,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -41693,13 +43616,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T213 : IType, new()
        where T214 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -41716,6 +43642,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -41939,6 +43868,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -41950,13 +43882,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -42175,13 +44115,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T214 : IType, new()
        where T215 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -42198,6 +44141,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -42422,6 +44368,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -42433,13 +44382,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -42659,13 +44616,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T215 : IType, new()
        where T216 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -42682,6 +44642,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -42907,6 +44870,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -42918,13 +44884,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -43145,13 +45119,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T216 : IType, new()
        where T217 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -43168,6 +45145,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -43394,6 +45374,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -43405,13 +45388,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -43633,13 +45624,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T217 : IType, new()
        where T218 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -43656,6 +45650,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -43883,6 +45880,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -43894,13 +45894,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -44123,13 +46131,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T218 : IType, new()
        where T219 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -44146,6 +46157,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -44374,6 +46388,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -44385,13 +46402,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -44615,13 +46640,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T219 : IType, new()
        where T220 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -44638,6 +46666,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -44867,6 +46898,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -44878,13 +46912,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -45109,13 +47151,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T220 : IType, new()
        where T221 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -45132,6 +47177,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -45362,6 +47410,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -45373,13 +47424,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -45605,13 +47664,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T221 : IType, new()
        where T222 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -45628,6 +47690,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -45859,6 +47924,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -45870,13 +47938,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -46103,13 +48179,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T222 : IType, new()
        where T223 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -46126,6 +48205,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -46358,6 +48440,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -46369,13 +48454,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -46603,13 +48696,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T223 : IType, new()
        where T224 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -46626,6 +48722,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -46859,6 +48958,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -46870,13 +48972,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -47105,13 +49215,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T224 : IType, new()
        where T225 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -47128,6 +49241,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -47362,6 +49478,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -47373,13 +49492,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -47609,13 +49736,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T225 : IType, new()
        where T226 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -47632,6 +49762,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -47867,6 +50000,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -47878,13 +50014,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -48115,13 +50259,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T226 : IType, new()
        where T227 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -48138,6 +50285,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -48374,6 +50524,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -48385,13 +50538,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -48623,13 +50784,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T227 : IType, new()
        where T228 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -48646,6 +50810,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -48883,6 +51050,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -48894,13 +51064,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -49133,13 +51311,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T228 : IType, new()
        where T229 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -49156,6 +51337,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -49394,6 +51578,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -49405,13 +51592,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -49645,13 +51840,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T229 : IType, new()
        where T230 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -49668,6 +51866,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -49907,6 +52108,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -49918,13 +52122,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -50159,13 +52371,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T230 : IType, new()
        where T231 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -50182,6 +52397,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -50422,6 +52640,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -50433,13 +52654,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -50675,13 +52904,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T231 : IType, new()
        where T232 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -50698,6 +52930,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -50939,6 +53174,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -50950,13 +53188,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -51193,13 +53439,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T232 : IType, new()
        where T233 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -51216,6 +53465,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -51458,6 +53710,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -51469,13 +53724,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -51713,13 +53976,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T233 : IType, new()
        where T234 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -51736,6 +54002,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -51979,6 +54248,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -51990,13 +54262,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -52235,13 +54515,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T234 : IType, new()
        where T235 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -52258,6 +54541,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -52502,6 +54788,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -52513,13 +54802,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -52759,13 +55056,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T235 : IType, new()
        where T236 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -52782,6 +55082,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -53027,6 +55330,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -53038,13 +55344,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -53285,13 +55599,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T236 : IType, new()
        where T237 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -53308,6 +55625,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -53554,6 +55874,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -53565,13 +55888,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -53813,13 +56144,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T237 : IType, new()
        where T238 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -53836,6 +56170,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -54083,6 +56420,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -54094,13 +56434,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -54343,13 +56691,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T238 : IType, new()
        where T239 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -54366,6 +56717,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -54614,6 +56968,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -54625,13 +56982,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -54875,13 +57240,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T239 : IType, new()
        where T240 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -54898,6 +57266,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -55147,6 +57518,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -55158,13 +57532,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -55409,13 +57791,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T240 : IType, new()
        where T241 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -55432,6 +57817,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -55682,6 +58070,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -55693,13 +58084,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -55945,13 +58344,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T241 : IType, new()
        where T242 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -55968,6 +58370,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -56219,6 +58624,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -56230,13 +58638,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -56483,13 +58899,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T242 : IType, new()
        where T243 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -56506,6 +58925,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -56758,6 +59180,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -56769,13 +59194,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -57023,13 +59456,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T243 : IType, new()
        where T244 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -57046,6 +59482,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -57299,6 +59738,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -57310,13 +59752,21 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -57565,13 +60015,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T244 : IType, new()
        where T245 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -57588,6 +60041,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -57842,6 +60298,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -57853,5553 +60312,25 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //   where T250 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            case 0xF9: return DecodeType<T250>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250, T251> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //   where T250 : IType, new()
-    //   where T251 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            case 0xF9: return DecodeType<T250>(byteArray, ref p);
-    //            case 0xFA: return DecodeType<T251>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250, T251, T252> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //   where T250 : IType, new()
-    //   where T251 : IType, new()
-    //   where T252 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            case 0xF9: return DecodeType<T250>(byteArray, ref p);
-    //            case 0xFA: return DecodeType<T251>(byteArray, ref p);
-    //            case 0xFB: return DecodeType<T252>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250, T251, T252, T253> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //   where T250 : IType, new()
-    //   where T251 : IType, new()
-    //   where T252 : IType, new()
-    //   where T253 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            case 0xF9: return DecodeType<T250>(byteArray, ref p);
-    //            case 0xFA: return DecodeType<T251>(byteArray, ref p);
-    //            case 0xFB: return DecodeType<T252>(byteArray, ref p);
-    //            case 0xFC: return DecodeType<T253>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250, T251, T252, T253, T254> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //   where T250 : IType, new()
-    //   where T251 : IType, new()
-    //   where T252 : IType, new()
-    //   where T253 : IType, new()
-    //   where T254 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            case 0xF9: return DecodeType<T250>(byteArray, ref p);
-    //            case 0xFA: return DecodeType<T251>(byteArray, ref p);
-    //            case 0xFB: return DecodeType<T252>(byteArray, ref p);
-    //            case 0xFC: return DecodeType<T253>(byteArray, ref p);
-    //            case 0xFD: return DecodeType<T254>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
-    //public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250, T251, T252, T253, T254, T255> : BaseEnumType
-    //   where T0 : Enum
-    //   where T1 : IType, new()
-    //   where T2 : IType, new()
-    //   where T3 : IType, new()
-    //   where T4 : IType, new()
-    //   where T5 : IType, new()
-    //   where T6 : IType, new()
-    //   where T7 : IType, new()
-    //   where T8 : IType, new()
-    //   where T9 : IType, new()
-    //   where T10 : IType, new()
-    //   where T11 : IType, new()
-    //   where T12 : IType, new()
-    //   where T13 : IType, new()
-    //   where T14 : IType, new()
-    //   where T15 : IType, new()
-    //   where T16 : IType, new()
-    //   where T17 : IType, new()
-    //   where T18 : IType, new()
-    //   where T19 : IType, new()
-    //   where T20 : IType, new()
-    //   where T21 : IType, new()
-    //   where T22 : IType, new()
-    //   where T23 : IType, new()
-    //   where T24 : IType, new()
-    //   where T25 : IType, new()
-    //   where T26 : IType, new()
-    //   where T27 : IType, new()
-    //   where T28 : IType, new()
-    //   where T29 : IType, new()
-    //   where T30 : IType, new()
-    //   where T31 : IType, new()
-    //   where T32 : IType, new()
-    //   where T33 : IType, new()
-    //   where T34 : IType, new()
-    //   where T35 : IType, new()
-    //   where T36 : IType, new()
-    //   where T37 : IType, new()
-    //   where T38 : IType, new()
-    //   where T39 : IType, new()
-    //   where T40 : IType, new()
-    //   where T41 : IType, new()
-    //   where T42 : IType, new()
-    //   where T43 : IType, new()
-    //   where T44 : IType, new()
-    //   where T45 : IType, new()
-    //   where T46 : IType, new()
-    //   where T47 : IType, new()
-    //   where T48 : IType, new()
-    //   where T49 : IType, new()
-    //   where T50 : IType, new()
-    //   where T51 : IType, new()
-    //   where T52 : IType, new()
-    //   where T53 : IType, new()
-    //   where T54 : IType, new()
-    //   where T55 : IType, new()
-    //   where T56 : IType, new()
-    //   where T57 : IType, new()
-    //   where T58 : IType, new()
-    //   where T59 : IType, new()
-    //   where T60 : IType, new()
-    //   where T61 : IType, new()
-    //   where T62 : IType, new()
-    //   where T63 : IType, new()
-    //   where T64 : IType, new()
-    //   where T65 : IType, new()
-    //   where T66 : IType, new()
-    //   where T67 : IType, new()
-    //   where T68 : IType, new()
-    //   where T69 : IType, new()
-    //   where T70 : IType, new()
-    //   where T71 : IType, new()
-    //   where T72 : IType, new()
-    //   where T73 : IType, new()
-    //   where T74 : IType, new()
-    //   where T75 : IType, new()
-    //   where T76 : IType, new()
-    //   where T77 : IType, new()
-    //   where T78 : IType, new()
-    //   where T79 : IType, new()
-    //   where T80 : IType, new()
-    //   where T81 : IType, new()
-    //   where T82 : IType, new()
-    //   where T83 : IType, new()
-    //   where T84 : IType, new()
-    //   where T85 : IType, new()
-    //   where T86 : IType, new()
-    //   where T87 : IType, new()
-    //   where T88 : IType, new()
-    //   where T89 : IType, new()
-    //   where T90 : IType, new()
-    //   where T91 : IType, new()
-    //   where T92 : IType, new()
-    //   where T93 : IType, new()
-    //   where T94 : IType, new()
-    //   where T95 : IType, new()
-    //   where T96 : IType, new()
-    //   where T97 : IType, new()
-    //   where T98 : IType, new()
-    //   where T99 : IType, new()
-    //   where T100 : IType, new()
-    //   where T101 : IType, new()
-    //   where T102 : IType, new()
-    //   where T103 : IType, new()
-    //   where T104 : IType, new()
-    //   where T105 : IType, new()
-    //   where T106 : IType, new()
-    //   where T107 : IType, new()
-    //   where T108 : IType, new()
-    //   where T109 : IType, new()
-    //   where T110 : IType, new()
-    //   where T111 : IType, new()
-    //   where T112 : IType, new()
-    //   where T113 : IType, new()
-    //   where T114 : IType, new()
-    //   where T115 : IType, new()
-    //   where T116 : IType, new()
-    //   where T117 : IType, new()
-    //   where T118 : IType, new()
-    //   where T119 : IType, new()
-    //   where T120 : IType, new()
-    //   where T121 : IType, new()
-    //   where T122 : IType, new()
-    //   where T123 : IType, new()
-    //   where T124 : IType, new()
-    //   where T125 : IType, new()
-    //   where T126 : IType, new()
-    //   where T127 : IType, new()
-    //   where T128 : IType, new()
-    //   where T129 : IType, new()
-    //   where T130 : IType, new()
-    //   where T131 : IType, new()
-    //   where T132 : IType, new()
-    //   where T133 : IType, new()
-    //   where T134 : IType, new()
-    //   where T135 : IType, new()
-    //   where T136 : IType, new()
-    //   where T137 : IType, new()
-    //   where T138 : IType, new()
-    //   where T139 : IType, new()
-    //   where T140 : IType, new()
-    //   where T141 : IType, new()
-    //   where T142 : IType, new()
-    //   where T143 : IType, new()
-    //   where T144 : IType, new()
-    //   where T145 : IType, new()
-    //   where T146 : IType, new()
-    //   where T147 : IType, new()
-    //   where T148 : IType, new()
-    //   where T149 : IType, new()
-    //   where T150 : IType, new()
-    //   where T151 : IType, new()
-    //   where T152 : IType, new()
-    //   where T153 : IType, new()
-    //   where T154 : IType, new()
-    //   where T155 : IType, new()
-    //   where T156 : IType, new()
-    //   where T157 : IType, new()
-    //   where T158 : IType, new()
-    //   where T159 : IType, new()
-    //   where T160 : IType, new()
-    //   where T161 : IType, new()
-    //   where T162 : IType, new()
-    //   where T163 : IType, new()
-    //   where T164 : IType, new()
-    //   where T165 : IType, new()
-    //   where T166 : IType, new()
-    //   where T167 : IType, new()
-    //   where T168 : IType, new()
-    //   where T169 : IType, new()
-    //   where T170 : IType, new()
-    //   where T171 : IType, new()
-    //   where T172 : IType, new()
-    //   where T173 : IType, new()
-    //   where T174 : IType, new()
-    //   where T175 : IType, new()
-    //   where T176 : IType, new()
-    //   where T177 : IType, new()
-    //   where T178 : IType, new()
-    //   where T179 : IType, new()
-    //   where T180 : IType, new()
-    //   where T181 : IType, new()
-    //   where T182 : IType, new()
-    //   where T183 : IType, new()
-    //   where T184 : IType, new()
-    //   where T185 : IType, new()
-    //   where T186 : IType, new()
-    //   where T187 : IType, new()
-    //   where T188 : IType, new()
-    //   where T189 : IType, new()
-    //   where T190 : IType, new()
-    //   where T191 : IType, new()
-    //   where T192 : IType, new()
-    //   where T193 : IType, new()
-    //   where T194 : IType, new()
-    //   where T195 : IType, new()
-    //   where T196 : IType, new()
-    //   where T197 : IType, new()
-    //   where T198 : IType, new()
-    //   where T199 : IType, new()
-    //   where T200 : IType, new()
-    //   where T201 : IType, new()
-    //   where T202 : IType, new()
-    //   where T203 : IType, new()
-    //   where T204 : IType, new()
-    //   where T205 : IType, new()
-    //   where T206 : IType, new()
-    //   where T207 : IType, new()
-    //   where T208 : IType, new()
-    //   where T209 : IType, new()
-    //   where T210 : IType, new()
-    //   where T211 : IType, new()
-    //   where T212 : IType, new()
-    //   where T213 : IType, new()
-    //   where T214 : IType, new()
-    //   where T215 : IType, new()
-    //   where T216 : IType, new()
-    //   where T217 : IType, new()
-    //   where T218 : IType, new()
-    //   where T219 : IType, new()
-    //   where T220 : IType, new()
-    //   where T221 : IType, new()
-    //   where T222 : IType, new()
-    //   where T223 : IType, new()
-    //   where T224 : IType, new()
-    //   where T225 : IType, new()
-    //   where T226 : IType, new()
-    //   where T227 : IType, new()
-    //   where T228 : IType, new()
-    //   where T229 : IType, new()
-    //   where T230 : IType, new()
-    //   where T231 : IType, new()
-    //   where T232 : IType, new()
-    //   where T233 : IType, new()
-    //   where T234 : IType, new()
-    //   where T235 : IType, new()
-    //   where T236 : IType, new()
-    //   where T237 : IType, new()
-    //   where T238 : IType, new()
-    //   where T239 : IType, new()
-    //   where T240 : IType, new()
-    //   where T241 : IType, new()
-    //   where T242 : IType, new()
-    //   where T243 : IType, new()
-    //   where T244 : IType, new()
-    //   where T245 : IType, new()
-    //   where T246 : IType, new()
-    //   where T247 : IType, new()
-    //   where T248 : IType, new()
-    //   where T249 : IType, new()
-    //   where T250 : IType, new()
-    //   where T251 : IType, new()
-    //   where T252 : IType, new()
-    //   where T253 : IType, new()
-    //   where T254 : IType, new()
-    //   where T255 : IType, new()
-    //{
-    //    public override string TypeName() => typeof(T0).Name;
-
-    //    public override byte[] Encode()
-    //    {
-    //        return Bytes;
-    //    }
-
-    //    public override void Decode(byte[] byteArray, ref int p)
-    //    {
-    //        var start = p;
-    //        var enumByte = byteArray[p];
-
-    //        Value = (T0)Enum.Parse(typeof(T0), enumByte.ToString(), true);
-    //        p += 1;
-
-    //        Value2 = DecodeOneOf(enumByte, byteArray, ref p);
-
-    //        TypeSize = p - start;
-
-    //        Bytes = new byte[TypeSize];
-    //        Array.Copy(byteArray, start, Bytes, 0, TypeSize);
-    //    }
-
-    //    private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
-    //    {
-    //        switch (value)
-    //        {
-    //            case 0x00: return DecodeType<T1>(byteArray, ref p);
-    //            case 0x01: return DecodeType<T2>(byteArray, ref p);
-    //            case 0x02: return DecodeType<T3>(byteArray, ref p);
-    //            case 0x03: return DecodeType<T4>(byteArray, ref p);
-    //            case 0x04: return DecodeType<T5>(byteArray, ref p);
-    //            case 0x05: return DecodeType<T6>(byteArray, ref p);
-    //            case 0x06: return DecodeType<T7>(byteArray, ref p);
-    //            case 0x07: return DecodeType<T8>(byteArray, ref p);
-    //            case 0x08: return DecodeType<T9>(byteArray, ref p);
-    //            case 0x09: return DecodeType<T10>(byteArray, ref p);
-    //            case 0x0A: return DecodeType<T11>(byteArray, ref p);
-    //            case 0x0B: return DecodeType<T12>(byteArray, ref p);
-    //            case 0x0C: return DecodeType<T13>(byteArray, ref p);
-    //            case 0x0D: return DecodeType<T14>(byteArray, ref p);
-    //            case 0x0E: return DecodeType<T15>(byteArray, ref p);
-    //            case 0x0F: return DecodeType<T16>(byteArray, ref p);
-    //            case 0x10: return DecodeType<T17>(byteArray, ref p);
-    //            case 0x11: return DecodeType<T18>(byteArray, ref p);
-    //            case 0x12: return DecodeType<T19>(byteArray, ref p);
-    //            case 0x13: return DecodeType<T20>(byteArray, ref p);
-    //            case 0x14: return DecodeType<T21>(byteArray, ref p);
-    //            case 0x15: return DecodeType<T22>(byteArray, ref p);
-    //            case 0x16: return DecodeType<T23>(byteArray, ref p);
-    //            case 0x17: return DecodeType<T24>(byteArray, ref p);
-    //            case 0x18: return DecodeType<T25>(byteArray, ref p);
-    //            case 0x19: return DecodeType<T26>(byteArray, ref p);
-    //            case 0x1A: return DecodeType<T27>(byteArray, ref p);
-    //            case 0x1B: return DecodeType<T28>(byteArray, ref p);
-    //            case 0x1C: return DecodeType<T29>(byteArray, ref p);
-    //            case 0x1D: return DecodeType<T30>(byteArray, ref p);
-    //            case 0x1E: return DecodeType<T31>(byteArray, ref p);
-    //            case 0x1F: return DecodeType<T32>(byteArray, ref p);
-    //            case 0x20: return DecodeType<T33>(byteArray, ref p);
-    //            case 0x21: return DecodeType<T34>(byteArray, ref p);
-    //            case 0x22: return DecodeType<T35>(byteArray, ref p);
-    //            case 0x23: return DecodeType<T36>(byteArray, ref p);
-    //            case 0x24: return DecodeType<T37>(byteArray, ref p);
-    //            case 0x25: return DecodeType<T38>(byteArray, ref p);
-    //            case 0x26: return DecodeType<T39>(byteArray, ref p);
-    //            case 0x27: return DecodeType<T40>(byteArray, ref p);
-    //            case 0x28: return DecodeType<T41>(byteArray, ref p);
-    //            case 0x29: return DecodeType<T42>(byteArray, ref p);
-    //            case 0x2A: return DecodeType<T43>(byteArray, ref p);
-    //            case 0x2B: return DecodeType<T44>(byteArray, ref p);
-    //            case 0x2C: return DecodeType<T45>(byteArray, ref p);
-    //            case 0x2D: return DecodeType<T46>(byteArray, ref p);
-    //            case 0x2E: return DecodeType<T47>(byteArray, ref p);
-    //            case 0x2F: return DecodeType<T48>(byteArray, ref p);
-    //            case 0x30: return DecodeType<T49>(byteArray, ref p);
-    //            case 0x31: return DecodeType<T50>(byteArray, ref p);
-    //            case 0x32: return DecodeType<T51>(byteArray, ref p);
-    //            case 0x33: return DecodeType<T52>(byteArray, ref p);
-    //            case 0x34: return DecodeType<T53>(byteArray, ref p);
-    //            case 0x35: return DecodeType<T54>(byteArray, ref p);
-    //            case 0x36: return DecodeType<T55>(byteArray, ref p);
-    //            case 0x37: return DecodeType<T56>(byteArray, ref p);
-    //            case 0x38: return DecodeType<T57>(byteArray, ref p);
-    //            case 0x39: return DecodeType<T58>(byteArray, ref p);
-    //            case 0x3A: return DecodeType<T59>(byteArray, ref p);
-    //            case 0x3B: return DecodeType<T60>(byteArray, ref p);
-    //            case 0x3C: return DecodeType<T61>(byteArray, ref p);
-    //            case 0x3D: return DecodeType<T62>(byteArray, ref p);
-    //            case 0x3E: return DecodeType<T63>(byteArray, ref p);
-    //            case 0x3F: return DecodeType<T64>(byteArray, ref p);
-    //            case 0x40: return DecodeType<T65>(byteArray, ref p);
-    //            case 0x41: return DecodeType<T66>(byteArray, ref p);
-    //            case 0x42: return DecodeType<T67>(byteArray, ref p);
-    //            case 0x43: return DecodeType<T68>(byteArray, ref p);
-    //            case 0x44: return DecodeType<T69>(byteArray, ref p);
-    //            case 0x45: return DecodeType<T70>(byteArray, ref p);
-    //            case 0x46: return DecodeType<T71>(byteArray, ref p);
-    //            case 0x47: return DecodeType<T72>(byteArray, ref p);
-    //            case 0x48: return DecodeType<T73>(byteArray, ref p);
-    //            case 0x49: return DecodeType<T74>(byteArray, ref p);
-    //            case 0x4A: return DecodeType<T75>(byteArray, ref p);
-    //            case 0x4B: return DecodeType<T76>(byteArray, ref p);
-    //            case 0x4C: return DecodeType<T77>(byteArray, ref p);
-    //            case 0x4D: return DecodeType<T78>(byteArray, ref p);
-    //            case 0x4E: return DecodeType<T79>(byteArray, ref p);
-    //            case 0x4F: return DecodeType<T80>(byteArray, ref p);
-    //            case 0x50: return DecodeType<T81>(byteArray, ref p);
-    //            case 0x51: return DecodeType<T82>(byteArray, ref p);
-    //            case 0x52: return DecodeType<T83>(byteArray, ref p);
-    //            case 0x53: return DecodeType<T84>(byteArray, ref p);
-    //            case 0x54: return DecodeType<T85>(byteArray, ref p);
-    //            case 0x55: return DecodeType<T86>(byteArray, ref p);
-    //            case 0x56: return DecodeType<T87>(byteArray, ref p);
-    //            case 0x57: return DecodeType<T88>(byteArray, ref p);
-    //            case 0x58: return DecodeType<T89>(byteArray, ref p);
-    //            case 0x59: return DecodeType<T90>(byteArray, ref p);
-    //            case 0x5A: return DecodeType<T91>(byteArray, ref p);
-    //            case 0x5B: return DecodeType<T92>(byteArray, ref p);
-    //            case 0x5C: return DecodeType<T93>(byteArray, ref p);
-    //            case 0x5D: return DecodeType<T94>(byteArray, ref p);
-    //            case 0x5E: return DecodeType<T95>(byteArray, ref p);
-    //            case 0x5F: return DecodeType<T96>(byteArray, ref p);
-    //            case 0x60: return DecodeType<T97>(byteArray, ref p);
-    //            case 0x61: return DecodeType<T98>(byteArray, ref p);
-    //            case 0x62: return DecodeType<T99>(byteArray, ref p);
-    //            case 0x63: return DecodeType<T100>(byteArray, ref p);
-    //            case 0x64: return DecodeType<T101>(byteArray, ref p);
-    //            case 0x65: return DecodeType<T102>(byteArray, ref p);
-    //            case 0x66: return DecodeType<T103>(byteArray, ref p);
-    //            case 0x67: return DecodeType<T104>(byteArray, ref p);
-    //            case 0x68: return DecodeType<T105>(byteArray, ref p);
-    //            case 0x69: return DecodeType<T106>(byteArray, ref p);
-    //            case 0x6A: return DecodeType<T107>(byteArray, ref p);
-    //            case 0x6B: return DecodeType<T108>(byteArray, ref p);
-    //            case 0x6C: return DecodeType<T109>(byteArray, ref p);
-    //            case 0x6D: return DecodeType<T110>(byteArray, ref p);
-    //            case 0x6E: return DecodeType<T111>(byteArray, ref p);
-    //            case 0x6F: return DecodeType<T112>(byteArray, ref p);
-    //            case 0x70: return DecodeType<T113>(byteArray, ref p);
-    //            case 0x71: return DecodeType<T114>(byteArray, ref p);
-    //            case 0x72: return DecodeType<T115>(byteArray, ref p);
-    //            case 0x73: return DecodeType<T116>(byteArray, ref p);
-    //            case 0x74: return DecodeType<T117>(byteArray, ref p);
-    //            case 0x75: return DecodeType<T118>(byteArray, ref p);
-    //            case 0x76: return DecodeType<T119>(byteArray, ref p);
-    //            case 0x77: return DecodeType<T120>(byteArray, ref p);
-    //            case 0x78: return DecodeType<T121>(byteArray, ref p);
-    //            case 0x79: return DecodeType<T122>(byteArray, ref p);
-    //            case 0x7A: return DecodeType<T123>(byteArray, ref p);
-    //            case 0x7B: return DecodeType<T124>(byteArray, ref p);
-    //            case 0x7C: return DecodeType<T125>(byteArray, ref p);
-    //            case 0x7D: return DecodeType<T126>(byteArray, ref p);
-    //            case 0x7E: return DecodeType<T127>(byteArray, ref p);
-    //            case 0x7F: return DecodeType<T128>(byteArray, ref p);
-    //            case 0x80: return DecodeType<T129>(byteArray, ref p);
-    //            case 0x81: return DecodeType<T130>(byteArray, ref p);
-    //            case 0x82: return DecodeType<T131>(byteArray, ref p);
-    //            case 0x83: return DecodeType<T132>(byteArray, ref p);
-    //            case 0x84: return DecodeType<T133>(byteArray, ref p);
-    //            case 0x85: return DecodeType<T134>(byteArray, ref p);
-    //            case 0x86: return DecodeType<T135>(byteArray, ref p);
-    //            case 0x87: return DecodeType<T136>(byteArray, ref p);
-    //            case 0x88: return DecodeType<T137>(byteArray, ref p);
-    //            case 0x89: return DecodeType<T138>(byteArray, ref p);
-    //            case 0x8A: return DecodeType<T139>(byteArray, ref p);
-    //            case 0x8B: return DecodeType<T140>(byteArray, ref p);
-    //            case 0x8C: return DecodeType<T141>(byteArray, ref p);
-    //            case 0x8D: return DecodeType<T142>(byteArray, ref p);
-    //            case 0x8E: return DecodeType<T143>(byteArray, ref p);
-    //            case 0x8F: return DecodeType<T144>(byteArray, ref p);
-    //            case 0x90: return DecodeType<T145>(byteArray, ref p);
-    //            case 0x91: return DecodeType<T146>(byteArray, ref p);
-    //            case 0x92: return DecodeType<T147>(byteArray, ref p);
-    //            case 0x93: return DecodeType<T148>(byteArray, ref p);
-    //            case 0x94: return DecodeType<T149>(byteArray, ref p);
-    //            case 0x95: return DecodeType<T150>(byteArray, ref p);
-    //            case 0x96: return DecodeType<T151>(byteArray, ref p);
-    //            case 0x97: return DecodeType<T152>(byteArray, ref p);
-    //            case 0x98: return DecodeType<T153>(byteArray, ref p);
-    //            case 0x99: return DecodeType<T154>(byteArray, ref p);
-    //            case 0x9A: return DecodeType<T155>(byteArray, ref p);
-    //            case 0x9B: return DecodeType<T156>(byteArray, ref p);
-    //            case 0x9C: return DecodeType<T157>(byteArray, ref p);
-    //            case 0x9D: return DecodeType<T158>(byteArray, ref p);
-    //            case 0x9E: return DecodeType<T159>(byteArray, ref p);
-    //            case 0x9F: return DecodeType<T160>(byteArray, ref p);
-    //            case 0xA0: return DecodeType<T161>(byteArray, ref p);
-    //            case 0xA1: return DecodeType<T162>(byteArray, ref p);
-    //            case 0xA2: return DecodeType<T163>(byteArray, ref p);
-    //            case 0xA3: return DecodeType<T164>(byteArray, ref p);
-    //            case 0xA4: return DecodeType<T165>(byteArray, ref p);
-    //            case 0xA5: return DecodeType<T166>(byteArray, ref p);
-    //            case 0xA6: return DecodeType<T167>(byteArray, ref p);
-    //            case 0xA7: return DecodeType<T168>(byteArray, ref p);
-    //            case 0xA8: return DecodeType<T169>(byteArray, ref p);
-    //            case 0xA9: return DecodeType<T170>(byteArray, ref p);
-    //            case 0xAA: return DecodeType<T171>(byteArray, ref p);
-    //            case 0xAB: return DecodeType<T172>(byteArray, ref p);
-    //            case 0xAC: return DecodeType<T173>(byteArray, ref p);
-    //            case 0xAD: return DecodeType<T174>(byteArray, ref p);
-    //            case 0xAE: return DecodeType<T175>(byteArray, ref p);
-    //            case 0xAF: return DecodeType<T176>(byteArray, ref p);
-    //            case 0xB0: return DecodeType<T177>(byteArray, ref p);
-    //            case 0xB1: return DecodeType<T178>(byteArray, ref p);
-    //            case 0xB2: return DecodeType<T179>(byteArray, ref p);
-    //            case 0xB3: return DecodeType<T180>(byteArray, ref p);
-    //            case 0xB4: return DecodeType<T181>(byteArray, ref p);
-    //            case 0xB5: return DecodeType<T182>(byteArray, ref p);
-    //            case 0xB6: return DecodeType<T183>(byteArray, ref p);
-    //            case 0xB7: return DecodeType<T184>(byteArray, ref p);
-    //            case 0xB8: return DecodeType<T185>(byteArray, ref p);
-    //            case 0xB9: return DecodeType<T186>(byteArray, ref p);
-    //            case 0xBA: return DecodeType<T187>(byteArray, ref p);
-    //            case 0xBB: return DecodeType<T188>(byteArray, ref p);
-    //            case 0xBC: return DecodeType<T189>(byteArray, ref p);
-    //            case 0xBD: return DecodeType<T190>(byteArray, ref p);
-    //            case 0xBE: return DecodeType<T191>(byteArray, ref p);
-    //            case 0xBF: return DecodeType<T192>(byteArray, ref p);
-    //            case 0xC0: return DecodeType<T193>(byteArray, ref p);
-    //            case 0xC1: return DecodeType<T194>(byteArray, ref p);
-    //            case 0xC2: return DecodeType<T195>(byteArray, ref p);
-    //            case 0xC3: return DecodeType<T196>(byteArray, ref p);
-    //            case 0xC4: return DecodeType<T197>(byteArray, ref p);
-    //            case 0xC5: return DecodeType<T198>(byteArray, ref p);
-    //            case 0xC6: return DecodeType<T199>(byteArray, ref p);
-    //            case 0xC7: return DecodeType<T200>(byteArray, ref p);
-    //            case 0xC8: return DecodeType<T201>(byteArray, ref p);
-    //            case 0xC9: return DecodeType<T202>(byteArray, ref p);
-    //            case 0xCA: return DecodeType<T203>(byteArray, ref p);
-    //            case 0xCB: return DecodeType<T204>(byteArray, ref p);
-    //            case 0xCC: return DecodeType<T205>(byteArray, ref p);
-    //            case 0xCD: return DecodeType<T206>(byteArray, ref p);
-    //            case 0xCE: return DecodeType<T207>(byteArray, ref p);
-    //            case 0xCF: return DecodeType<T208>(byteArray, ref p);
-    //            case 0xD0: return DecodeType<T209>(byteArray, ref p);
-    //            case 0xD1: return DecodeType<T210>(byteArray, ref p);
-    //            case 0xD2: return DecodeType<T211>(byteArray, ref p);
-    //            case 0xD3: return DecodeType<T212>(byteArray, ref p);
-    //            case 0xD4: return DecodeType<T213>(byteArray, ref p);
-    //            case 0xD5: return DecodeType<T214>(byteArray, ref p);
-    //            case 0xD6: return DecodeType<T215>(byteArray, ref p);
-    //            case 0xD7: return DecodeType<T216>(byteArray, ref p);
-    //            case 0xD8: return DecodeType<T217>(byteArray, ref p);
-    //            case 0xD9: return DecodeType<T218>(byteArray, ref p);
-    //            case 0xDA: return DecodeType<T219>(byteArray, ref p);
-    //            case 0xDB: return DecodeType<T220>(byteArray, ref p);
-    //            case 0xDC: return DecodeType<T221>(byteArray, ref p);
-    //            case 0xDD: return DecodeType<T222>(byteArray, ref p);
-    //            case 0xDE: return DecodeType<T223>(byteArray, ref p);
-    //            case 0xDF: return DecodeType<T224>(byteArray, ref p);
-    //            case 0xE0: return DecodeType<T225>(byteArray, ref p);
-    //            case 0xE1: return DecodeType<T226>(byteArray, ref p);
-    //            case 0xE2: return DecodeType<T227>(byteArray, ref p);
-    //            case 0xE3: return DecodeType<T228>(byteArray, ref p);
-    //            case 0xE4: return DecodeType<T229>(byteArray, ref p);
-    //            case 0xE5: return DecodeType<T230>(byteArray, ref p);
-    //            case 0xE6: return DecodeType<T231>(byteArray, ref p);
-    //            case 0xE7: return DecodeType<T232>(byteArray, ref p);
-    //            case 0xE8: return DecodeType<T233>(byteArray, ref p);
-    //            case 0xE9: return DecodeType<T234>(byteArray, ref p);
-    //            case 0xEA: return DecodeType<T235>(byteArray, ref p);
-    //            case 0xEB: return DecodeType<T236>(byteArray, ref p);
-    //            case 0xEC: return DecodeType<T237>(byteArray, ref p);
-    //            case 0xED: return DecodeType<T238>(byteArray, ref p);
-    //            case 0xEE: return DecodeType<T239>(byteArray, ref p);
-    //            case 0xEF: return DecodeType<T240>(byteArray, ref p);
-    //            case 0xF0: return DecodeType<T241>(byteArray, ref p);
-    //            case 0xF1: return DecodeType<T242>(byteArray, ref p);
-    //            case 0xF2: return DecodeType<T243>(byteArray, ref p);
-    //            case 0xF3: return DecodeType<T244>(byteArray, ref p);
-    //            case 0xF4: return DecodeType<T245>(byteArray, ref p);
-    //            case 0xF5: return DecodeType<T246>(byteArray, ref p);
-    //            case 0xF6: return DecodeType<T247>(byteArray, ref p);
-    //            case 0xF7: return DecodeType<T248>(byteArray, ref p);
-    //            case 0xF8: return DecodeType<T249>(byteArray, ref p);
-    //            case 0xF9: return DecodeType<T250>(byteArray, ref p);
-    //            case 0xFA: return DecodeType<T251>(byteArray, ref p);
-    //            case 0xFB: return DecodeType<T252>(byteArray, ref p);
-    //            case 0xFC: return DecodeType<T253>(byteArray, ref p);
-    //            case 0xFD: return DecodeType<T254>(byteArray, ref p);
-    //            case 0xFE: return DecodeType<T255>(byteArray, ref p);
-    //            default:
-    //                return null;
-    //        }
-    //    }
-
-    //    public void Create(T0 t, IType value2)
-    //    {
-    //        List<byte> bytes = new List<byte>();
-    //        bytes.Add(Convert.ToByte(t));
-    //        bytes.AddRange(value2.Encode());
-    //        Bytes = bytes.ToArray();
-    //        Value = t;
-    //        Value2 = value2;
-    //        TypeSize = Bytes.Length;
-    //    }
-
-    //    public override string ToString() => JsonConvert.SerializeObject(Value);
-
-    //    [JsonConverter(typeof(StringEnumConverter))]
-    //    public T0 Value { get; set; }
-
-    //    public IType Value2 { get; set; }
-    //}
+
+    // 246 - 255 are being removed due to a Unity bug in il2cpp
+    // https://forum.unity.com/threads/il2cpp-build-crashes-after-unity-logo.1513730
+
+    /// <inheritdoc/>
     public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T120, T121, T122, T123, T124, T125, T126, T127, T128, T129, T130, T131, T132, T133, T134, T135, T136, T137, T138, T139, T140, T141, T142, T143, T144, T145, T146, T147, T148, T149, T150, T151, T152, T153, T154, T155, T156, T157, T158, T159, T160, T161, T162, T163, T164, T165, T166, T167, T168, T169, T170, T171, T172, T173, T174, T175, T176, T177, T178, T179, T180, T181, T182, T183, T184, T185, T186, T187, T188, T189, T190, T191, T192, T193, T194, T195, T196, T197, T198, T199, T200, T201, T202, T203, T204, T205, T206, T207, T208, T209, T210, T211, T212, T213, T214, T215, T216, T217, T218, T219, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229, T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T240, T241, T242, T243, T244, T245, T246, T247, T248, T249, T250, T251, T252, T253, T254, T255, T256> : BaseEnumType
        where T0 : Enum
        where T1 : IType, new()
@@ -63659,13 +60590,16 @@ public class BaseEnumExt<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
        where T255 : IType, new()
        where T256 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName() => typeof(T0).Name;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -63682,6 +60616,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// BaseEnumExt DecodeOneOf
+        /// </summary>
         private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
         {
             switch (value)
@@ -63947,6 +60884,9 @@ private IType DecodeOneOf(byte value, byte[] byteArray, ref int p)
             }
         }
 
+        /// <summary>
+        /// BaseEnumExt Create
+        /// </summary>
         public void Create(T0 t, IType value2)
         {
             List<byte> bytes = new List<byte>();
@@ -63958,11 +60898,19 @@ public void Create(T0 t, IType value2)
             TypeSize = Bytes.Length;
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// BaseEnumExt Enumeration Value
+        /// </summary>
         [JsonConverter(typeof(StringEnumConverter))]
         public T0 Value { get; set; }
 
+        /// <summary>
+        /// BaseEnumExt Type Value
+        /// </summary>
         public IType Value2 { get; set; }
     }
+
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseOpt.cs b/Substrate.NetApi/Model/Types/Base/BaseOpt.cs
index 83e10db..add7e46 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseOpt.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseOpt.cs
@@ -5,27 +5,60 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base Option Type
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class BaseOpt<T> : IType where T : IType, new()
     {
+        /// <summary>
+        /// Explicit conversion from T to BaseOpt
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator BaseOpt<T>(T p) => new BaseOpt<T>(p);
 
+        /// <summary>
+        /// Explicit conversion from BaseOpt to T
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator T(BaseOpt<T> p) => p.OptionFlag ? p.Value : throw new InvalidOperationException("Option is None");
 
+        /// <summary>
+        /// Base Option Constructor
+        /// </summary>
         public BaseOpt()
         { }
 
+        /// <summary>
+        /// Base Option Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public BaseOpt(T value)
         {
             Create(value);
         }
 
+        /// <summary>
+        /// Type Name
+        /// </summary>
+        /// <returns></returns>
         public virtual string TypeName() => $"Option<{new T().TypeName()}>";
 
+        /// <summary>
+        /// Type Size
+        /// </summary>
         public int TypeSize { get; set; }
 
+        /// <summary>
+        /// Bytes
+        /// </summary>
         [JsonIgnore]
         public byte[] Bytes { get; internal set; }
 
+        /// <summary>
+        /// Encode to Bytes
+        /// </summary>
+        /// <returns></returns>
         public byte[] Encode()
         {
             var bytes = new List<byte>();
@@ -42,6 +75,11 @@ public byte[] Encode()
             return bytes.ToArray();
         }
 
+        /// <summary>
+        /// Decode from a byte array at certain position
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -67,10 +105,20 @@ public void Decode(byte[] byteArray, ref int p)
             Value = t != null ? t : default;
         }
 
+        /// <summary>
+        /// Option Flag
+        /// </summary>
         public bool OptionFlag { get; set; }
 
+        /// <summary>
+        /// Value
+        /// </summary>
         public T Value { get; internal set; }
 
+        /// <summary>
+        /// Create from a string
+        /// </summary>
+        /// <param name="value"></param>
         public void Create(T value)
         {
             OptionFlag = value != null;
@@ -79,18 +127,35 @@ public void Create(T value)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Create from a string
+        /// </summary>
+        /// <param name="str"></param>
         public void Create(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// Create from a json string
+        /// </summary>
+        /// <param name="str"></param>
         public void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// Create from a byte array
+        /// </summary>
+        /// <param name="byteArray"></param>
         public void Create(byte[] byteArray)
         {
             var p = 0;
             Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// New
+        /// </summary>
+        /// <returns></returns>
         public IType New() => this;
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(this);
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BasePrim.cs b/Substrate.NetApi/Model/Types/Base/BasePrim.cs
index 966426d..2af5332 100644
--- a/Substrate.NetApi/Model/Types/Base/BasePrim.cs
+++ b/Substrate.NetApi/Model/Types/Base/BasePrim.cs
@@ -3,18 +3,38 @@
 
 namespace Substrate.NetApi.Model.Types
 {
+    /// <summary>
+    /// Abstract Base Primitive Type
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public abstract class BasePrim<T> : BaseType
     {
+        /// <summary>
+        /// Base Primitive Constructor
+        /// </summary>
         protected BasePrim()
         { }
 
+        /// <summary>
+        /// Base Primitive Constructor
+        /// </summary>
+        /// <param name="value"></param>
         protected BasePrim(T value)
         {
             Create(value);
         }
 
+        /// <summary>
+        /// Base Primitive Create
+        /// </summary>
+        /// <param name="value"></param>
         public abstract void Create(T value);
 
+        /// <summary>
+        /// Base Primitive Decode
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var memory = byteArray.AsMemory();
@@ -23,8 +43,15 @@ public override void Decode(byte[] byteArray, ref int p)
             Create(result);
         }
 
+        /// <summary>
+        /// Base Primitive to string
+        /// </summary>
+        /// <returns></returns>
         public override string ToString() => this.Value.ToString();
 
+        /// <summary>
+        /// Base Primitive Value
+        /// </summary>
         public T Value { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseTuple.cs b/Substrate.NetApi/Model/Types/Base/BaseTuple.cs
index 865aaba..8215bf1 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseTuple.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseTuple.cs
@@ -3,44 +3,60 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return new byte[0];
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             TypeSize = 0;
             Bytes = new byte[0];
         }
 
+        /// <summary>
+        /// Value
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1> : BaseType
                             where T1 : IType, new()
     {
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple()
         { }
 
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple(T1 t1)
         {
             Create(t1);
         }
-
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
                 new T1().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -50,7 +66,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -65,6 +81,10 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
+        /// <param name="t1"></param>
         public void Create(T1 t1)
         {
             var byteList = new List<byte>();
@@ -77,28 +97,40 @@ public void Create(T1 t1)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
     {
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple()
         { }
 
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple(T1 t1, T2 t2)
         {
             Create(t1, t2);
         }
-
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
                 new T1().TypeName() + "," +
                 new T2().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -108,7 +140,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -126,6 +158,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2)
         {
             var byteList = new List<byte>();
@@ -140,22 +175,34 @@ public void Create(T1 t1, T2 t2)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
                             where T3 : IType, new()
     {
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple()
         { }
 
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple(T1 t1, T2 t2, T3 t3)
         {
             Create(t1, t2, t3);
         }
-
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -163,7 +210,7 @@ public override string TypeName()
                 new T2().TypeName() + "," +
                 new T3().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -173,7 +220,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -194,6 +241,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3)
         {
             var byteList = new List<byte>();
@@ -210,23 +260,36 @@ public void Create(T1 t1, T2 t2, T3 t3)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
                             where T3 : IType, new()
                             where T4 : IType, new()
     {
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple()
         { }
 
+        /// <summary>
+        /// Base Tuple constructor
+        /// </summary>
         public BaseTuple(T1 t1, T2 t2, T3 t3, T4 t4)
         {
             Create(t1, t2, t3, t4);
         }
 
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -236,6 +299,7 @@ public override string TypeName()
                 new T4().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -245,7 +309,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -269,6 +333,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4)
         {
             var byteList = new List<byte>();
@@ -287,9 +354,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -297,6 +370,7 @@ public class BaseTuple<T1, T2, T3, T4, T5> : BaseType
                             where T4 : IType, new()
                             where T5 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -306,7 +380,7 @@ public override string TypeName()
                 new T4().TypeName() + "," +
                 new T5().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -316,7 +390,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -343,6 +417,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
         {
             var byteList = new List<byte>();
@@ -363,9 +440,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -374,6 +457,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6> : BaseType
                             where T5 : IType, new()
                             where T6 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -384,7 +468,7 @@ public override string TypeName()
                 new T5().TypeName() + "," +
                 new T6().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -394,7 +478,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -424,6 +508,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
         {
             var byteList = new List<byte>();
@@ -446,9 +533,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -458,6 +551,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7> : BaseType
                             where T6 : IType, new()
                             where T7 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -469,7 +563,7 @@ public override string TypeName()
                 new T6().TypeName() + "," +
                 new T7().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -479,7 +573,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -512,6 +606,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
         {
             var byteList = new List<byte>();
@@ -536,9 +633,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -549,6 +652,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8> : BaseType
                             where T7 : IType, new()
                             where T8 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -561,7 +665,7 @@ public override string TypeName()
                 new T7().TypeName() + "," +
                 new T8().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -571,7 +675,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -607,6 +711,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
         {
             var byteList = new List<byte>();
@@ -633,9 +740,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -647,6 +760,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> : BaseType
                             where T8 : IType, new()
                             where T9 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -660,7 +774,7 @@ public override string TypeName()
                 new T8().TypeName() + "," +
                 new T9().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -670,7 +784,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -709,6 +823,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
         {
             var byteList = new List<byte>();
@@ -737,9 +854,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -752,6 +875,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> : BaseType
                             where T9 : IType, new()
                             where T10 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -766,7 +890,7 @@ public override string TypeName()
                 new T9().TypeName() + "," +
                 new T10().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -776,7 +900,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -818,6 +942,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)
         {
             var byteList = new List<byte>();
@@ -848,9 +975,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -864,6 +997,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : BaseType
                             where T10 : IType, new()
                             where T11 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -880,6 +1014,7 @@ public override string TypeName()
                 new T11().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -890,6 +1025,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -934,6 +1070,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11)
         {
             var byteList = new List<byte>();
@@ -966,9 +1105,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -983,6 +1128,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : Base
                             where T11 : IType, new()
                             where T12 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1000,6 +1146,7 @@ public override string TypeName()
                 new T12().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1010,6 +1157,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1057,6 +1205,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12)
         {
             var byteList = new List<byte>();
@@ -1091,9 +1242,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -1109,6 +1266,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> :
                             where T12 : IType, new()
                             where T13 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1127,6 +1285,7 @@ public override string TypeName()
                 new T13().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1137,6 +1296,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1187,6 +1347,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13)
         {
             var byteList = new List<byte>();
@@ -1223,9 +1386,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -1242,6 +1411,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T13 : IType, new()
                             where T14 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1261,6 +1431,7 @@ public override string TypeName()
                 new T14().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1271,6 +1442,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1324,6 +1496,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14)
         {
             var byteList = new List<byte>();
@@ -1362,9 +1537,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -1382,6 +1563,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T14 : IType, new()
                             where T15 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1402,6 +1584,7 @@ public override string TypeName()
                 new T15().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1412,6 +1595,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1468,6 +1652,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15)
         {
             var byteList = new List<byte>();
@@ -1508,9 +1695,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -1529,6 +1722,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T15 : IType, new()
                             where T16 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1550,6 +1744,7 @@ public override string TypeName()
                 new T16().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1560,6 +1755,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1619,6 +1815,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16)
         {
             var byteList = new List<byte>();
@@ -1661,9 +1860,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -1683,6 +1888,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T16 : IType, new()
                             where T17 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1705,6 +1911,7 @@ public override string TypeName()
                 new T17().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1715,6 +1922,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1777,6 +1985,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17)
         {
             var byteList = new List<byte>();
@@ -1821,9 +2032,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -1844,6 +2061,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T17 : IType, new()
                             where T18 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -1867,6 +2085,7 @@ public override string TypeName()
                 new T18().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -1877,6 +2096,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -1942,6 +2162,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18)
         {
             var byteList = new List<byte>();
@@ -1988,9 +2211,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -2012,6 +2241,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T18 : IType, new()
                             where T19 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -2036,6 +2266,7 @@ public override string TypeName()
                 new T19().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -2046,6 +2277,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2114,6 +2346,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19)
         {
             var byteList = new List<byte>();
@@ -2162,9 +2397,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -2187,6 +2428,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T19 : IType, new()
                             where T20 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -2212,6 +2454,7 @@ public override string TypeName()
                 new T20().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -2222,6 +2465,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2293,6 +2537,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20)
         {
             var byteList = new List<byte>();
@@ -2343,9 +2590,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
-
+    
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -2369,6 +2622,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T20 : IType, new()
                             where T21 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -2395,6 +2649,7 @@ public override string TypeName()
                 new T21().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -2405,6 +2660,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2479,6 +2735,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21)
         {
             var byteList = new List<byte>();
@@ -2531,9 +2790,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -2558,6 +2823,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T21 : IType, new()
                             where T22 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -2585,6 +2851,7 @@ public override string TypeName()
                 new T22().TypeName() + ")";
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -2595,6 +2862,7 @@ public override byte[] Encode()
             return result.ToArray();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2672,6 +2940,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22)
         {
             var byteList = new List<byte>();
@@ -2726,9 +2997,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -2754,6 +3031,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T22 : IType, new()
                             where T23 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -2781,7 +3059,7 @@ public override string TypeName()
                 new T22().TypeName() + "," +
                 new T23().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -2791,7 +3069,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -2872,6 +3150,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23)
         {
             var byteList = new List<byte>();
@@ -2928,9 +3209,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -2957,6 +3244,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T23 : IType, new()
                             where T24 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -2985,7 +3273,7 @@ public override string TypeName()
                 new T23().TypeName() + "," +
                 new T24().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -2995,7 +3283,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3079,6 +3367,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24)
         {
             var byteList = new List<byte>();
@@ -3137,9 +3428,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -3167,6 +3464,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T24 : IType, new()
                             where T25 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -3196,7 +3494,7 @@ public override string TypeName()
                 new T24().TypeName() + "," +
                 new T25().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -3206,7 +3504,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3293,6 +3591,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25)
         {
             var byteList = new List<byte>();
@@ -3353,9 +3654,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -3384,6 +3691,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T25 : IType, new()
                             where T26 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -3414,7 +3722,7 @@ public override string TypeName()
                 new T25().TypeName() + "," +
                 new T26().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -3424,7 +3732,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3514,6 +3822,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26)
         {
             var byteList = new List<byte>();
@@ -3576,9 +3887,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -3608,6 +3925,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T26 : IType, new()
                             where T27 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -3639,7 +3957,7 @@ public override string TypeName()
                 new T26().TypeName() + "," +
                 new T27().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -3649,7 +3967,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3742,6 +4060,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27)
         {
             var byteList = new List<byte>();
@@ -3806,9 +4127,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -3839,6 +4166,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T27 : IType, new()
                             where T28 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -3871,7 +4199,7 @@ public override string TypeName()
                 new T27().TypeName() + "," +
                 new T28().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -3881,7 +4209,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -3977,6 +4305,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28)
         {
             var byteList = new List<byte>();
@@ -4043,9 +4374,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -4077,6 +4414,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T28 : IType, new()
                             where T29 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -4110,7 +4448,7 @@ public override string TypeName()
                 new T28().TypeName() + "," +
                 new T29().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -4120,7 +4458,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4219,6 +4557,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29)
         {
             var byteList = new List<byte>();
@@ -4287,9 +4628,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -4322,6 +4669,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T29 : IType, new()
                             where T30 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -4356,8 +4704,9 @@ public override string TypeName()
                 new T29().TypeName() + "," +
                 new T30().TypeName() + ")";
         }
-
-        public override byte[] Encode()
+        
+       /// <inheritdoc/>
+       public override byte[] Encode()
         {
             var result = new List<byte>();
             foreach (var v in Value)
@@ -4366,7 +4715,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4468,6 +4817,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30)
         {
             var byteList = new List<byte>();
@@ -4538,9 +4890,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -4574,6 +4932,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T30 : IType, new()
                             where T31 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -4609,7 +4968,7 @@ public override string TypeName()
                 new T30().TypeName() + "," +
                 new T31().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -4619,7 +4978,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4724,6 +5083,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31)
         {
             var byteList = new List<byte>();
@@ -4796,9 +5158,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -4833,6 +5201,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T31 : IType, new()
                             where T32 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -4869,7 +5238,7 @@ public override string TypeName()
                 new T31().TypeName() + "," +
                 new T32().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -4879,7 +5248,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -4987,6 +5356,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32)
         {
             var byteList = new List<byte>();
@@ -5061,9 +5433,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -5099,6 +5477,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T32 : IType, new()
                             where T33 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -5136,7 +5515,7 @@ public override string TypeName()
                 new T32().TypeName() + "," +
                 new T33().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -5146,7 +5525,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5257,6 +5636,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33)
         {
             var byteList = new List<byte>();
@@ -5333,9 +5715,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -5372,6 +5760,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T33 : IType, new()
                             where T34 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -5410,7 +5799,7 @@ public override string TypeName()
                 new T33().TypeName() + "," +
                 new T34().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -5420,7 +5809,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5534,6 +5923,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33, T34 t34)
         {
             var byteList = new List<byte>();
@@ -5612,9 +6004,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -5652,6 +6050,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T34 : IType, new()
                             where T35 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -5691,7 +6090,7 @@ public override string TypeName()
                 new T34().TypeName() + "," +
                 new T35().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -5701,7 +6100,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -5818,6 +6217,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33, T34 t34, T35 t35)
         {
             var byteList = new List<byte>();
@@ -5898,9 +6300,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -5939,6 +6347,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T35 : IType, new()
                             where T36 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -5979,7 +6388,7 @@ public override string TypeName()
                 new T35().TypeName() + "," +
                 new T36().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -5989,7 +6398,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6109,6 +6518,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33, T34 t34, T35 t35, T36 t36)
         {
             var byteList = new List<byte>();
@@ -6191,9 +6603,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -6233,6 +6651,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T36 : IType, new()
                             where T37 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -6274,7 +6693,7 @@ public override string TypeName()
                 new T36().TypeName() + "," +
                 new T37().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -6284,7 +6703,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6407,6 +6826,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33, T34 t34, T35 t35, T36 t36, T37 t37)
         {
             var byteList = new List<byte>();
@@ -6491,9 +6913,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -6534,6 +6962,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T37 : IType, new()
                             where T38 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -6576,7 +7005,7 @@ public override string TypeName()
                 new T37().TypeName() + "," +
                 new T38().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -6586,7 +7015,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -6712,6 +7141,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33, T34 t34, T35 t35, T36 t36, T37 t37, T38 t38)
         {
             var byteList = new List<byte>();
@@ -6798,9 +7230,15 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 
+    /// <summary>
+    /// Base class for multiple tuples type
+    /// </summary>
     public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> : BaseType
                             where T1 : IType, new()
                             where T2 : IType, new()
@@ -6842,6 +7280,7 @@ public class BaseTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
                             where T38 : IType, new()
                             where T39 : IType, new()
     {
+        /// <inheritdoc/>
         public override string TypeName()
         {
             return "(" +
@@ -6885,7 +7324,7 @@ public override string TypeName()
                 new T38().TypeName() + "," +
                 new T39().TypeName() + ")";
         }
-
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var result = new List<byte>();
@@ -6895,7 +7334,7 @@ public override byte[] Encode()
             }
             return result.ToArray();
         }
-
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -7024,6 +7463,9 @@ public override void Decode(byte[] byteArray, ref int p)
             Array.Copy(byteArray, start, Bytes, 0, TypeSize);
         }
 
+        /// <summary>
+        /// Create tuple
+        /// </summary>
         public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22, T23 t23, T24 t24, T25 t25, T26 t26, T27 t27, T28 t28, T29 t29, T30 t30, T31 t31, T32 t32, T33 t33, T34 t34, T35 t35, T36 t36, T37 t37, T38 t38, T39 t39)
         {
             var byteList = new List<byte>();
@@ -7112,6 +7554,9 @@ public void Create(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// Value of tuple
+        /// </summary>
         public IType[] Value { get; internal set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseType.cs b/Substrate.NetApi/Model/Types/Base/BaseType.cs
index 7e3212b..d39c2c4 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseType.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseType.cs
@@ -2,22 +2,52 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base Type
+    /// </summary>
     public abstract class BaseType : IType
     {
+        /// <summary>
+        /// Type Name
+        /// </summary>
+        /// <returns></returns>
         public virtual string TypeName() => GetType().Name;
 
+        /// <summary>
+        /// Type Size
+        /// </summary>
         [JsonIgnore]
         public virtual int TypeSize { get; set; }
 
+        /// <summary>
+        /// Bytes
+        /// </summary>
         [JsonIgnore]
         public byte[] Bytes { get; set; }
 
+        /// <summary>
+        /// Encode to Bytes
+        /// </summary>
+        /// <returns></returns>
         public abstract byte[] Encode();
 
+        /// <summary>
+        /// Decode from a byte array at certain position
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public abstract void Decode(byte[] byteArray, ref int p);
 
+        /// <summary>
+        /// Create from a string
+        /// </summary>
+        /// <param name="str"></param>
         public virtual void Create(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// Create from a byte array
+        /// </summary>
+        /// <param name="byteArray"></param>
         public virtual void Create(byte[] byteArray)
         {
             var p = 0;
@@ -25,10 +55,19 @@ public virtual void Create(byte[] byteArray)
             Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// Create from a json string
+        /// </summary>
+        /// <param name="str"></param>
         public virtual void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// New
+        /// </summary>
+        /// <returns></returns>
         public IType New() => this;
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(this);
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseVec.cs b/Substrate.NetApi/Model/Types/Base/BaseVec.cs
index 897bdaf..0d99e63 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseVec.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseVec.cs
@@ -4,27 +4,60 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base Vec Type
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class BaseVec<T> : IType where T : IType, new()
     {
+        /// <summary>
+        /// Explicit conversion from T[] to BaseVec
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator BaseVec<T>(T[] p) => new BaseVec<T>(p);
 
+        /// <summary>
+        /// Implicit conversion from BaseVec to T[]
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator T[](BaseVec<T> p) => p.Value;
 
+        /// <summary>
+        /// BaseVec Constructor
+        /// </summary>
         public BaseVec()
         { }
 
+        /// <summary>
+        /// BaseVec Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public BaseVec(T[] value)
         {
             Create(value);
         }
 
+        /// <summary>
+        /// BaseVec Type Name
+        /// </summary>
+        /// <returns></returns>
         public virtual string TypeName() => $"Vec<{new T().TypeName()}>";
 
+        /// <summary>
+        /// BaseVec Type Size
+        /// </summary>
         public int TypeSize { get; set; }
 
+        /// <summary>
+        /// BaseVec Bytes
+        /// </summary>
         [JsonIgnore]
         public byte[] Bytes { get; internal set; }
 
+        /// <summary>
+        /// BaseVec Encode
+        /// </summary>
+        /// <returns></returns>
         public byte[] Encode()
         {
             var result = new List<byte>();
@@ -36,6 +69,11 @@ public byte[] Encode()
             return result.ToArray();
         }
 
+        /// <summary>
+        /// BaseVec Decode
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -57,8 +95,15 @@ public void Decode(byte[] byteArray, ref int p)
             Value = array;
         }
 
+        /// <summary>
+        /// BaseVec Value
+        /// </summary>
         public virtual T[] Value { get; internal set; }
 
+        /// <summary>
+        /// BaseVec Create
+        /// </summary>
+        /// <param name="list"></param>
         public void Create(T[] list)
         {
             Value = list;
@@ -67,18 +112,35 @@ public void Create(T[] list)
             TypeSize = Bytes.Length;
         }
 
+        /// <summary>
+        /// BaseVec Create
+        /// </summary>
+        /// <param name="str"></param>
         public void Create(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// BaseVec Create From Json
+        /// </summary>
+        /// <param name="str"></param>
         public void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
 
+        /// <summary>
+        /// BaseVec Create
+        /// </summary>
+        /// <param name="byteArray"></param>
         public void Create(byte[] byteArray)
         {
             var p = 0;
             Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// BaseVec New
+        /// </summary>
+        /// <returns></returns>
         public IType New() => this;
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(this);
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseVoid.cs b/Substrate.NetApi/Model/Types/Base/BaseVoid.cs
index 0c8ac4f..31224e4 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseVoid.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseVoid.cs
@@ -1,16 +1,23 @@
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Base Void Type
+    /// </summary>
     public class BaseVoid : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "Void";
 
+        /// <inheritdoc/>
         public override int TypeSize => 0;
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             Bytes = new byte[] { };
         }
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return new byte[] { };
diff --git a/Substrate.NetApi/Model/Types/Base/BlockNumber.cs b/Substrate.NetApi/Model/Types/Base/BlockNumber.cs
index f063dd2..f845f77 100644
--- a/Substrate.NetApi/Model/Types/Base/BlockNumber.cs
+++ b/Substrate.NetApi/Model/Types/Base/BlockNumber.cs
@@ -2,24 +2,46 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// BlockNumber Type
+    /// </summary>
     public class BlockNumber : BasePrim<uint>
     {
+        /// <summary>
+        /// Explicit conversion to BlockNumber
+        /// </summary>
+        /// <param name="p"></param>
+
         public static explicit operator BlockNumber(uint p) => new BlockNumber(p);
 
+        /// <summary>
+        /// Implicit conversion to uint
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator uint(BlockNumber p) => p.Value;
 
+        /// <summary>
+        /// BlockNumber Constructor
+        /// </summary>
         public BlockNumber()
         { }
 
+        /// <summary>
+        /// BlockNumber Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public BlockNumber(uint value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "T::BlockNumber";
 
+        /// <inheritdoc/>
         public override int TypeSize => 4;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             var reversed = Bytes;
@@ -27,12 +49,14 @@ public override byte[] Encode()
             return reversed;
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = BitConverter.ToUInt32(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(uint value)
         {
             Bytes = BitConverter.GetBytes(value);
diff --git a/Substrate.NetApi/Model/Types/Base/Hash.cs b/Substrate.NetApi/Model/Types/Base/Hash.cs
index d15cd2b..dc7c00d 100644
--- a/Substrate.NetApi/Model/Types/Base/Hash.cs
+++ b/Substrate.NetApi/Model/Types/Base/Hash.cs
@@ -3,40 +3,67 @@
 
 namespace Substrate.NetApi.Model.Types.Base
 {
+    /// <summary>
+    /// Hash Type
+    /// </summary>
     public class Hash : BasePrim<string>
     {
+        /// <summary>
+        /// Explicit conversion from byte[] to Hash
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator Hash(byte[] p) => new Hash(p);
 
+        /// <summary>
+        /// Implicit conversion from Hash to byte[]
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator byte[](Hash p) => p.Bytes;
 
+        /// <summary>
+        /// Hash Constructor
+        /// </summary>
         public Hash()
         { }
 
+        /// <summary>
+        /// Hash Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public Hash(string value)
         {
             Create(value);
         }
 
+        /// <summary>
+        /// Hash Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public Hash(byte[] value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "T::Hash";
 
+        /// <inheritdoc/>
         public override int TypeSize => 32;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = Utils.Bytes2HexString(Bytes);
         }
 
+        /// <inheritdoc/>
         public override void Create(string value) => Create(Utils.HexToByteArray(value));
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/IEncodable.cs b/Substrate.NetApi/Model/Types/IEncodable.cs
index bc9148f..4aa22e2 100644
--- a/Substrate.NetApi/Model/Types/IEncodable.cs
+++ b/Substrate.NetApi/Model/Types/IEncodable.cs
@@ -1,7 +1,14 @@
 namespace Substrate.NetApi.Model.Types
 {
+    /// <summary>
+    /// Encodable Interface
+    /// </summary>
     public interface IEncodable
     {
+        /// <summary>
+        /// Encode
+        /// </summary>
+        /// <returns></returns>
         byte[] Encode();
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/IType.cs b/Substrate.NetApi/Model/Types/IType.cs
index 78cc083..9a615c3 100644
--- a/Substrate.NetApi/Model/Types/IType.cs
+++ b/Substrate.NetApi/Model/Types/IType.cs
@@ -37,18 +37,18 @@ public interface IType
         /// <param name="str">The string.</param>
         void Create(string str);
 
-        /// <summary>
-        /// Creates from json.
-        /// </summary>
-        /// <param name="str">The string.</param>
-        void CreateFromJson(string str);
-
         /// <summary>
         /// Creates the specified byte array.
         /// </summary>
         /// <param name="byteArray">The byte array.</param>
         void Create(byte[] byteArray);
 
+        /// <summary>
+        /// Creates from json.
+        /// </summary>
+        /// <param name="str">The string.</param>
+        void CreateFromJson(string str);
+
         /// <summary>
         /// News this instance.
         /// </summary>
diff --git a/Substrate.NetApi/Model/Types/Metadata/RuntimeMetadata.cs b/Substrate.NetApi/Model/Types/Metadata/RuntimeMetadata.cs
index 2fe6a4a..fa2e914 100644
--- a/Substrate.NetApi/Model/Types/Metadata/RuntimeMetadata.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/RuntimeMetadata.cs
@@ -4,15 +4,21 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata
 {
+    /// <summary>
+    /// Runtime Metadata Type
+    /// </summary>
     public class RuntimeMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "RuntimeMetadata";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -26,7 +32,14 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Meta Data Info
+        /// </summary>
         public MetaDataInfo MetaDataInfo { get; private set; }
+        
+        /// <summary>
+        /// Runtime Metadata Data
+        /// </summary>
         public RuntimeMetadataV14 RuntimeMetadataData { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/Field.cs b/Substrate.NetApi/Model/Types/Metadata/V14/Field.cs
index 08483fa..d6a6052 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/Field.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/Field.cs
@@ -4,15 +4,21 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Field Type
+    /// </summary>
     public class Field : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "Field<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32,9 +38,24 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Field Name
+        /// </summary>
         public BaseOpt<Str> FieldName { get; private set; }
+
+        /// <summary>
+        /// Field Type
+        /// </summary>
         public TType FieldTy { get; private set; }
+
+        /// <summary>
+        /// Field Type Name
+        /// </summary>
         public BaseOpt<Str> FieldTypeName { get; private set; }
+
+        /// <summary>
+        /// Docs
+        /// </summary>
         public BaseVec<Str> Docs { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/PortableRegistry.cs b/Substrate.NetApi/Model/Types/Metadata/V14/PortableRegistry.cs
index 079160a..09a60af 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/PortableRegistry.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/PortableRegistry.cs
@@ -2,8 +2,12 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Portable Registry
+    /// </summary>
     public class PortableRegistry : BaseVec<PortableType>
     {
+        /// <inheritdoc/>
         public override string TypeName() => "PortableRegistry";
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/PortableType.cs b/Substrate.NetApi/Model/Types/Metadata/V14/PortableType.cs
index 4ad6902..76d5d1f 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/PortableType.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/PortableType.cs
@@ -4,15 +4,21 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Portable Type
+    /// </summary>
     public class PortableType : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "PortableType";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -27,7 +33,14 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Id
+        /// </summary>
         public U32 Id { get; private set; }
+        
+        /// <summary>
+        /// Ty
+        /// </summary>
         public TypePortableForm Ty { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/RuntimeMetadataV14.cs b/Substrate.NetApi/Model/Types/Metadata/V14/RuntimeMetadataV14.cs
index 04a9445..0c4a5ba 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/RuntimeMetadataV14.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/RuntimeMetadataV14.cs
@@ -6,13 +6,18 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Runtime Metadata V14
+    /// </summary>
     public class RuntimeMetadataV14 : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32,22 +37,43 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Types
+        /// </summary>
         public PortableRegistry Types { get; private set; }
 
+        /// <summary>
+        /// Modules
+        /// </summary>
         public BaseVec<PalletMetadata> Modules { get; private set; }
 
+        /// <summary>
+        /// Extrinsic
+        /// </summary>
         public ExtrinsicMetadataStruct Extrinsic { get; private set; }
 
+        /// <summary>
+        /// Type Id
+        /// </summary>
         public TType TypeId { get; private set; }
     }
 
+    /// <summary>
+    /// Meta Data Info Type
+    /// </summary>
     public class MetaDataInfo : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Decode from byte array
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -61,17 +87,29 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Magic
+        /// </summary>
         public U32 Magic { get; private set; }
+
+        /// <summary>
+        /// Version
+        /// </summary>
         public U8 Version { get; private set; }
     }
 
+    /// <summary>
+    /// Palette Metadata
+    /// </summary>
     public class PalletMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -100,22 +138,54 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Palette Name
+        /// </summary>
         public Str PalletName { get; private set; }
+
+        /// <summary>
+        /// Palette Storage
+        /// </summary>
         public BaseOpt<StorageMetadata> PalletStorage { get; private set; }
+
+        /// <summary>
+        /// Palette Calls
+        /// </summary>
         public BaseOpt<PalletCallMetadata> PalletCalls { get; private set; }
+
+        /// <summary>
+        /// Palette Events
+        /// </summary>
         public BaseOpt<PalletEventMetadata> PalletEvents { get; private set; }
+
+        /// <summary>
+        /// Palette Constants
+        /// </summary>
         public BaseVec<PalletConstantMetadata> PalletConstants { get; private set; }
+
+        /// <summary>
+        /// Palette Errors
+        /// </summary>
         public BaseOpt<ErrorMetadata> PalletErrors { get; private set; }
+
+        /// <summary>
+        /// Index
+        /// </summary>
         public U8 Index { get; private set; }
     }
 
+    /// <summary>
+    /// Storage Metadata
+    /// </summary>
     public class StorageMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -129,17 +199,29 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Prefix
+        /// </summary>
         public Str Prefix { get; private set; }
+        
+        /// <summary>
+        /// Entries
+        /// </summary>
         public BaseVec<StorageEntryMetadata> Entries { get; private set; }
     }
 
+    /// <summary>
+    /// Storage Entry Metadata
+    /// </summary>
     public class StorageEntryMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -162,24 +244,51 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Storage Name
+        /// </summary>
         public Str StorageName { get; private set; }
+
+        /// <summary>
+        /// Storage Modifier
+        /// </summary>
         public BaseEnum<Modifier> StorageModifier { get; private set; }
+
+        /// <summary>
+        /// Storage Type
+        /// </summary>
         public BaseEnumExt<Storage.Type, TType, StorageEntryTypeMap> StorageType { get; private set; }
+
+        /// <summary>
+        /// Storage Default
+        /// </summary>
         public ByteGetter StorageDefault { get; private set; }
+
+        /// <summary>
+        /// Documentation
+        /// </summary>
         public BaseVec<Str> Documentation { get; private set; }
     }
 
+    /// <summary>
+    /// Byte Getter
+    /// </summary>
     public class ByteGetter : BaseVec<U8>
     {
     }
 
+    /// <summary>
+    /// Storage Entry Type Map
+    /// </summary>
     public class StorageEntryTypeMap : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -196,18 +305,34 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Hashers
+        /// </summary>
         public BaseVec<BaseEnum<Hasher>> Hashers { get; private set; }
+
+        /// <summary>
+        /// Key
+        /// </summary>
         public TType Key { get; private set; }
+        
+        /// <summary>
+        /// Value
+        /// </summary>
         public TType Value { get; private set; }
     }
 
+    /// <summary>
+    /// Pallet Call Metadata
+    /// </summary>
     public class PalletCallMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -218,16 +343,24 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Call Type
+        /// </summary>
         public TType CallType { get; private set; }
     }
 
+    /// <summary>
+    /// Palette Event Metadata
+    /// </summary>
     public class PalletEventMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -238,16 +371,32 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Event Type
+        /// </summary>
         public TType EventType { get; private set; }
     }
 
+    /// <summary>
+    /// Pallet Constant Metadata
+    /// </summary>
     public class PalletConstantMetadata : BaseType
     {
+        /// <summary>
+        /// Encode to Bytes
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Decode from a byte array at certain position
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -267,19 +416,39 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Constant Name
+        /// </summary>
         public Str ConstantName { get; private set; }
+
+        /// <summary>
+        /// Constant Type
+        /// </summary>
         public TType ConstantType { get; private set; }
+
+        /// <summary>
+        /// Constant Value
+        /// </summary>
         public ByteGetter ConstantValue { get; private set; }
+
+        /// <summary>
+        /// Documentation
+        /// </summary>
         public BaseVec<Str> Documentation { get; private set; }
     }
 
+    /// <summary>
+    /// Error Metadata
+    /// </summary>
     public class ErrorMetadata : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -290,16 +459,24 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Error Type
+        /// </summary>
         public TType ErrorType { get; private set; }
     }
 
+    /// <summary>
+    /// Extrinsic Metadata Struct
+    /// </summary>
     public class ExtrinsicMetadataStruct : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -316,18 +493,34 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Extrinsic Type
+        /// </summary>
         public TType ExtrinsicType { get; private set; }
+        
+        /// <summary>
+        /// Version
+        /// </summary>
         public U8 Version { get; private set; }
+        
+        /// <summary>
+        /// Signed Extensions
+        /// </summary>
         public BaseVec<SignedExtensionMetadataStruct> SignedExtensions { get; private set; }
     }
 
+    /// <summary>
+    /// Signed Extension Metadata Struct
+    /// </summary>
     public class SignedExtensionMetadataStruct : BaseType
     {
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -344,8 +537,19 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Signed Identifier
+        /// </summary>
         public Str SignedIdentifier { get; private set; }
+        
+        /// <summary>
+        /// Signed Extension Type
+        /// </summary>
         public TType SignedExtType { get; private set; }
+        
+        /// <summary>
+        /// Add Signed Extension Type
+        /// </summary>
         public TType AddSignedExtType { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/TypeDefs.cs b/Substrate.NetApi/Model/Types/Metadata/V14/TypeDefs.cs
index aaabf2b..3b75726 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/TypeDefs.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/TypeDefs.cs
@@ -5,49 +5,101 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Compact Integer Type
+    /// </summary>
     public class CompactIntegerType : IType
     {
+        /// <summary>
+        /// Type Name
+        /// </summary>
+        /// <returns></returns>
         public virtual string TypeName() => "CompactInteger";
 
+        /// <summary>
+        /// Type Size
+        /// </summary>
         public int TypeSize { get; set; } = 0;
 
+        /// <summary>
+        /// Create from string
+        /// </summary>
+        /// <param name="str"></param>
+        /// <exception cref="NotImplementedException"></exception>
         public void Create(string str)
         {
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Create from byte array
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <exception cref="NotImplementedException"></exception>
         public void Create(byte[] byteArray)
         {
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Create from Json
+        /// </summary>
+        /// <param name="str"></param>
+        /// <exception cref="NotImplementedException"></exception>
         public void CreateFromJson(string str)
         {
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Decode from byte array
+        /// </summary>
+        /// <param name="byteArray"></param>
+        /// <param name="p"></param>
         public void Decode(byte[] byteArray, ref int p)
         {
             Value = CompactInteger.Decode(byteArray, ref p);
         }
 
+        /// <summary>
+        /// Encode to byte array
+        /// </summary>
+        /// <returns></returns>
         public byte[] Encode()
         {
             return Value.Encode();
         }
 
+        /// <inheritdoc/>
         public override string ToString() => JsonConvert.SerializeObject(Value);
 
+        /// <summary>
+        /// New
+        /// </summary>
+        /// <returns></returns>
         public IType New() => this;
 
+        /// <summary>
+        /// Value
+        /// </summary>
         public CompactInteger Value { get; set; }
     }
 
+    /// <summary>
+    /// T Type Definition
+    /// </summary>
     public class TType : CompactIntegerType
     {
+        /// <summary>
+        /// Type Name
+        /// </summary>
+        /// <returns></returns>
         public override string TypeName() => "T::Type";
     }
 
+    /// <summary>
+    /// Type Definition Enum
+    /// </summary>
     public enum TypeDefEnum
     {
         /// A composite type (e.g. a struct or a tuple)
@@ -75,15 +127,21 @@ public enum TypeDefEnum
         BitSequence = 7
     }
 
+    /// <summary>
+    /// Type Definition Composite Type
+    /// </summary>
     public class TypeDefComposite : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefComposite<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -94,18 +152,27 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Fields
+        /// </summary>
         public BaseVec<Field> Fields { get; private set; }
     }
 
+    /// <summary>
+    /// Type Definition Variant Type
+    /// </summary>
     public class TypeDefVariant : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefVariant<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -116,18 +183,27 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Type Param
+        /// </summary>
         public BaseVec<Variant> TypeParam { get; private set; }
     }
 
+    /// <summary>
+    /// Type Definition Sequence Type
+    /// </summary>
     public class TypeDefSequence : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefSequence<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -138,18 +214,27 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Type Param
+        /// </summary>
         public TType TypeParam { get; private set; }
     }
 
+    /// <summary>
+    /// Type Definition Array Type
+    /// </summary>
     public class TypeDefArray : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefArray<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -163,19 +248,32 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Len
+        /// </summary>
         public U32 Len { get; private set; }
+        
+        /// <summary>
+        /// Type Param
+        /// </summary>
         public TType TypeParam { get; private set; }
     }
 
+    /// <summary>
+    /// Type Definition Tuple Type
+    /// </summary>
     public class TypeDefTuple : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefTuple<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -186,9 +284,15 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Fields
+        /// </summary>
         public BaseVec<TType> Fields { get; private set; }
     }
 
+    /// <summary>
+    /// Type Definition Primitive Type
+    /// </summary>
     public enum TypeDefPrimitive
     {
         /// `bool` type
@@ -237,15 +341,21 @@ public enum TypeDefPrimitive
         I256,
     }
 
+    /// <summary>
+    /// Type Definition Compact Type
+    /// </summary>
     public class TypeDefCompact : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefCompact<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -256,18 +366,27 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Type Param
+        /// </summary>
         public TType TypeParam { get; private set; }
     }
 
+    /// <summary>
+    /// Type Definition Bit Sequence Type
+    /// </summary>
     public class TypeDefBitSequence : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeDefBitSequence<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -281,7 +400,14 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Bit Store Type
+        /// </summary>
         public TType BitStoreType { get; private set; }
+        
+        /// <summary>
+        /// Bit Order Type
+        /// </summary>
         public TType BitOrderType { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/TypePortableForm.cs b/Substrate.NetApi/Model/Types/Metadata/V14/TypePortableForm.cs
index 9adcfb0..13e90f0 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/TypePortableForm.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/TypePortableForm.cs
@@ -4,15 +4,21 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Type Portable Form
+    /// </summary>
     public class TypePortableForm : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "Type<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32,26 +38,51 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Path
+        /// </summary>
         public Path Path { get; private set; }
+
+        /// <summary>
+        /// Type Parameters
+        /// </summary>
         public BaseVec<TypeParameter> TypeParams { get; private set; }
+
+        /// <summary>
+        /// Type Definition
+        /// </summary>
         public BaseEnumExt<TypeDefEnum, TypeDefComposite, TypeDefVariant, TypeDefSequence, TypeDefArray, TypeDefTuple, BaseEnum<TypeDefPrimitive>, TypeDefCompact, TypeDefBitSequence, BaseVoid> TypeDef { get; private set; }
+        
+        /// <summary>
+        /// Docs
+        /// </summary>
         public BaseVec<Str> Docs { get; private set; }
     }
 
+    /// <summary>
+    /// Path
+    /// </summary>
     public class Path : BaseVec<Str>
     {
+        /// <inheritdoc/>
         public override string TypeName() => "Path<T: Form = MetaForm>";
     }
 
+    /// <summary>
+    /// Type Parameter
+    /// </summary>
     public class TypeParameter : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "TypeParameter<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -65,7 +96,14 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Type Parameter Name
+        /// </summary>
         public Str TypeParameterName { get; private set; }
+
+        /// <summary>
+        /// Type Parameter Type
+        /// </summary>
         public BaseOpt<TType> TypeParameterType { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Metadata/V14/Variant.cs b/Substrate.NetApi/Model/Types/Metadata/V14/Variant.cs
index 074027d..750bf67 100644
--- a/Substrate.NetApi/Model/Types/Metadata/V14/Variant.cs
+++ b/Substrate.NetApi/Model/Types/Metadata/V14/Variant.cs
@@ -4,15 +4,21 @@
 
 namespace Substrate.NetApi.Model.Types.Metadata.V14
 {
+    /// <summary>
+    /// Variant Type
+    /// </summary>
     public class Variant : BaseType
     {
+        /// <inheritdoc/>
         public override string TypeName() => "Variant<T: Form = MetaForm>";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -32,9 +38,24 @@ public override void Decode(byte[] byteArray, ref int p)
             TypeSize = p - start;
         }
 
+        /// <summary>
+        /// Variant Name
+        /// </summary>
         public Str VariantName { get; private set; }
+
+        /// <summary>
+        /// Variant Fields
+        /// </summary>
         public BaseVec<Field> VariantFields { get; private set; }
+
+        /// <summary>
+        /// Index
+        /// </summary>
         public U8 Index { get; private set; }
+
+        /// <summary>
+        /// Docs
+        /// </summary>
         public BaseVec<Str> Docs { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Primitive/Bool.cs b/Substrate.NetApi/Model/Types/Primitive/Bool.cs
index 4d5a1d4..e93d830 100644
--- a/Substrate.NetApi/Model/Types/Primitive/Bool.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/Bool.cs
@@ -1,34 +1,57 @@
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// Bool Type
+    /// </summary>
     public class Bool : BasePrim<bool>
     {
+        /// <summary>
+        /// Explicit conversion to Bool
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator Bool(bool p) => new Bool(p);
 
+        /// <summary>
+        /// Implicit conversion to bool
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator bool(Bool p) => p.Value;
 
+        /// <summary>
+        /// Bool Constructor
+        /// </summary>
         public Bool()
         { }
 
+        /// <summary>
+        /// Bool Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public Bool(bool value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "bool";
 
+        /// <inheritdoc/>
         public override int TypeSize => 1;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = byteArray[0] > 0;
         }
 
+        /// <inheritdoc/>
         public override void Create(bool value)
         {
             Bytes = new byte[] { (byte)(value ? 0x01 : 0x00) };
diff --git a/Substrate.NetApi/Model/Types/Primitive/I128.cs b/Substrate.NetApi/Model/Types/Primitive/I128.cs
index 901f8ba..60b8b16 100644
--- a/Substrate.NetApi/Model/Types/Primitive/I128.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/I128.cs
@@ -3,29 +3,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// I128 Type
+    /// </summary>
     public class I128 : BasePrim<BigInteger>
     {
+        /// <summary>
+        /// Explicit conversion to I128
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator I128(BigInteger p) => new I128(p);
 
+        /// <summary>
+        /// Implicit conversion to BigInteger
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator BigInteger(I128 p) => p.Value;
 
+        /// <summary>
+        /// I128 Constructor
+        /// </summary>
         public I128()
         { }
 
+        /// <summary>
+        /// I128 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public I128(BigInteger value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "i128";
 
+        /// <inheritdoc/>
         public override int TypeSize => 16;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -35,6 +57,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -48,6 +71,7 @@ public override void Create(byte[] byteArray)
             Value = new BigInteger(byteArray);
         }
 
+        /// <inheritdoc/>
         public void Create(long value)
         {
             var bytes = new byte[TypeSize];
@@ -56,13 +80,14 @@ public void Create(long value)
             Value = value;
         }
 
+        /// <inheritdoc/>
         public override void Create(BigInteger value)
         {
             var byteArray = value.ToByteArray();
 
             if (byteArray.Length > TypeSize)
             {
-                throw new Exception($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
+                throw new NotSupportedException($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
             }
 
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/I16.cs b/Substrate.NetApi/Model/Types/Primitive/I16.cs
index ca11842..f068a84 100644
--- a/Substrate.NetApi/Model/Types/Primitive/I16.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/I16.cs
@@ -2,29 +2,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// I16 Type
+    /// </summary>
     public class I16 : BasePrim<short>
     {
+        /// <summary>
+        /// Explicit conversion to I16
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator I16(short p) => new I16(p);
 
+        /// <summary>
+        /// Implicit conversion to short
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator short(I16 p) => p.Value;
 
+        /// <summary>
+        /// I16 Constructor
+        /// </summary>
         public I16()
         { }
 
+        /// <summary>
+        /// I16 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public I16(short value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "i16";
 
+        /// <inheritdoc/>
         public override int TypeSize => 2;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -34,6 +56,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -47,6 +70,7 @@ public override void Create(byte[] byteArray)
             Value = BitConverter.ToInt16(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(short value)
         {
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/I256.cs b/Substrate.NetApi/Model/Types/Primitive/I256.cs
index 3bb64e2..5cf5753 100644
--- a/Substrate.NetApi/Model/Types/Primitive/I256.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/I256.cs
@@ -3,29 +3,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// I256 Type
+    /// </summary>
     public class I256 : BasePrim<BigInteger>
     {
+        /// <summary>
+        /// Explicit conversion to I256
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator I256(BigInteger p) => new I256(p);
 
+        /// <summary>
+        /// Implicit conversion to BigInteger
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator BigInteger(I256 p) => p.Value;
 
+        /// <summary>
+        /// I256 Constructor
+        /// </summary>
         public I256()
         { }
 
+        /// <summary>
+        /// I256 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public I256(BigInteger value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "i128";
 
+        /// <inheritdoc/>
         public override int TypeSize => 32;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -35,6 +57,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -48,21 +71,20 @@ public override void Create(byte[] byteArray)
             Value = new BigInteger(byteArray);
         }
 
+        /// <inheritdoc/>
         public void Create(long value)
         {
-            var bytes = new byte[TypeSize];
-            BitConverter.GetBytes(value).CopyTo(bytes, 0);
-            Bytes = bytes;
-            Value = value;
+            Create(new BigInteger(value));
         }
 
+        /// <inheritdoc/>
         public override void Create(BigInteger value)
         {
             var byteArray = value.ToByteArray();
 
             if (byteArray.Length > TypeSize)
             {
-                throw new Exception($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
+                throw new NotSupportedException($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
             }
 
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/I32.cs b/Substrate.NetApi/Model/Types/Primitive/I32.cs
index ae78792..e3301ce 100644
--- a/Substrate.NetApi/Model/Types/Primitive/I32.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/I32.cs
@@ -2,29 +2,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// I32
+    /// </summary>
     public class I32 : BasePrim<int>
     {
+        /// <summary>
+        /// Explicitly cast a int to a I32
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator I32(int p) => new I32(p);
 
+        /// <summary>
+        /// Implicitly cast a I32 to a int
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator int(I32 p) => p.Value;
 
+        /// <summary>
+        /// I32 Constructor
+        /// </summary>
         public I32()
         { }
 
+        /// <summary>
+        /// I32 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public I32(int value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "i32";
 
+        /// <inheritdoc/>
         public override int TypeSize => 4;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -34,6 +56,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -47,6 +70,7 @@ public override void Create(byte[] byteArray)
             Value = BitConverter.ToInt32(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(int value)
         {
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/I64.cs b/Substrate.NetApi/Model/Types/Primitive/I64.cs
index fe24e65..3140793 100644
--- a/Substrate.NetApi/Model/Types/Primitive/I64.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/I64.cs
@@ -2,29 +2,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// I64
+    /// </summary>
     public class I64 : BasePrim<long>
     {
+        /// <summary>
+        /// Explicitly cast a long to a I64
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator I64(long p) => new I64(p);
 
+        /// <summary>
+        /// Implicitly cast a I64 to a long
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator long(I64 p) => p.Value;
 
+        /// <summary>
+        /// I64 Constructor
+        /// </summary>
         public I64()
         { }
 
+        /// <summary>
+        /// I64 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public I64(long value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "i64";
 
+        /// <inheritdoc/>
         public override int TypeSize => 8;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -34,6 +56,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -47,6 +70,7 @@ public override void Create(byte[] byteArray)
             Value = BitConverter.ToInt64(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(long value)
         {
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/I8.cs b/Substrate.NetApi/Model/Types/Primitive/I8.cs
index a5a5fcd..67289e0 100644
--- a/Substrate.NetApi/Model/Types/Primitive/I8.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/I8.cs
@@ -1,34 +1,57 @@
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// I8
+    /// </summary>
     public class I8 : BasePrim<sbyte>
     {
+        /// <summary>
+        /// Explicitly cast a sbyte to a I8
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator I8(sbyte p) => new I8(p);
 
+        /// <summary>
+        /// Implicitly cast a I8 to a sbyte
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator sbyte(I8 p) => p.Value;
 
+        /// <summary>
+        /// I8 Constructor
+        /// </summary>
         public I8()
         { }
 
+        /// <summary>
+        /// I8 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public I8(sbyte value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "i8";
 
+        /// <inheritdoc/>
         public override int TypeSize => 1;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = (sbyte)byteArray[0];
         }
 
+        /// <inheritdoc/>
         public override void Create(sbyte value)
         {
             Bytes = new byte[] { (byte)value };
diff --git a/Substrate.NetApi/Model/Types/Primitive/PrimChar.cs b/Substrate.NetApi/Model/Types/Primitive/PrimChar.cs
index 3411032..0ed7c11 100644
--- a/Substrate.NetApi/Model/Types/Primitive/PrimChar.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/PrimChar.cs
@@ -3,35 +3,58 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// Char Primitive Type
+    /// </summary>
     public class PrimChar : BasePrim<char>
     {
+        /// <summary>
+        /// Explicitly cast a char to a PrimChar
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator PrimChar(char p) => new PrimChar(p);
 
+        /// <summary>
+        /// Implicitly cast a PrimChar to a char
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator char(PrimChar p) => p.Value;
 
+        /// <summary>
+        /// Prim Char Constructor
+        /// </summary>
         public PrimChar()
         { }
 
+        /// <summary>
+        /// Prim Char Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public PrimChar(char value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "char";
 
+        /// <inheritdoc/>
         public override int TypeSize => 1;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = Encoding.UTF8.GetString(byteArray)[0];
         }
 
+        /// <inheritdoc/>
         public override void Create(char value)
         {
             Bytes = Encoding.UTF8.GetBytes(value.ToString());
diff --git a/Substrate.NetApi/Model/Types/Primitive/Str.cs b/Substrate.NetApi/Model/Types/Primitive/Str.cs
index 46d3251..0f3e265 100644
--- a/Substrate.NetApi/Model/Types/Primitive/Str.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/Str.cs
@@ -4,27 +4,48 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// String Primitive Type
+    /// </summary>
     public class Str : BasePrim<string>
     {
+        /// <summary>
+        /// Explicitly cast a string to a Str
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator Str(string p) => new Str(p);
 
+        /// <summary>
+        /// Implicitly cast a Str to a string
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator string(Str p) => p.Value;
 
+        /// <summary>
+        /// Str Constructor
+        /// </summary>
         public Str()
         { }
 
+        /// <summary>
+        /// Str Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public Str(string value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "str";
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Utils.SizePrefixedByteArray(Encoding.UTF8.GetBytes(Value).ToList());
         }
 
+        /// <inheritdoc/>
         public override void Decode(byte[] byteArray, ref int p)
         {
             var start = p;
@@ -48,6 +69,7 @@ public override void Decode(byte[] byteArray, ref int p)
             Value = value;
         }
 
+        /// <inheritdoc/>
         public override void Create(string value)
         {
             Value = value;
diff --git a/Substrate.NetApi/Model/Types/Primitive/U128.cs b/Substrate.NetApi/Model/Types/Primitive/U128.cs
index 371ed95..51e3ed2 100644
--- a/Substrate.NetApi/Model/Types/Primitive/U128.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/U128.cs
@@ -3,29 +3,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// U128
+    /// </summary>
     public class U128 : BasePrim<BigInteger>
     {
+        /// <summary>
+        /// Explicitly cast a BigInteger to a U128
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator U128(BigInteger p) => new U128(p);
 
+        /// <summary>
+        /// Implicitly cast a U128 to a BigInteger
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator BigInteger(U128 p) => p.Value;
 
+        /// <summary>
+        /// U128 Constructor
+        /// </summary>
         public U128()
         { }
 
+        /// <summary>
+        /// U128 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public U128(BigInteger value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "u128";
 
+        /// <inheritdoc/>
         public override int TypeSize => 16;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -35,6 +57,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             // make sure it is unsigned we add 00 at the end
@@ -52,13 +75,14 @@ public override void Create(byte[] byteArray)
             }
             else
             {
-                throw new Exception($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
+                throw new NotSupportedException($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
             }
 
             Bytes = byteArray;
             Value = new BigInteger(byteArray);
         }
 
+        /// <inheritdoc/>
         public override void Create(BigInteger value)
         {
             // Ensure we have a positive number
@@ -69,7 +93,7 @@ public override void Create(BigInteger value)
 
             if (byteArray.Length > TypeSize)
             {
-                throw new Exception($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
+                throw new NotSupportedException($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
             }
 
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/U16.cs b/Substrate.NetApi/Model/Types/Primitive/U16.cs
index 220b342..b745753 100644
--- a/Substrate.NetApi/Model/Types/Primitive/U16.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/U16.cs
@@ -2,29 +2,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// U16
+    /// </summary>
     public class U16 : BasePrim<ushort>
     {
+        /// <summary>
+        /// Explicitly cast a ushort to a U16
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator U16(ushort p) => new U16(p);
 
+        /// <summary>
+        /// Implicitly cast a U16 to a ushort
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator ushort(U16 p) => p.Value;
 
+        /// <summary>
+        /// U16 Constructor
+        /// </summary>
         public U16()
         { }
 
+        /// <summary>
+        /// U16 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public U16(ushort value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "u16";
 
+        /// <inheritdoc/>
         public override int TypeSize => 2;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -34,6 +56,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -47,6 +70,7 @@ public override void Create(byte[] byteArray)
             Value = BitConverter.ToUInt16(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(ushort value)
         {
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/U256.cs b/Substrate.NetApi/Model/Types/Primitive/U256.cs
index 96ef845..60afd13 100644
--- a/Substrate.NetApi/Model/Types/Primitive/U256.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/U256.cs
@@ -3,29 +3,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// U256
+    /// </summary>
     public class U256 : BasePrim<BigInteger>
     {
+        /// <summary>
+        /// Explicitly cast a BigInteger to a U256
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator U256(BigInteger p) => new U256(p);
 
+        /// <summary>
+        /// Implicitly cast a U256 to a BigInteger
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator BigInteger(U256 p) => p.Value;
 
+        /// <summary>
+        /// U256 Constructor
+        /// </summary>
         public U256()
         { }
 
+        /// <summary>
+        /// U256 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public U256(BigInteger value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "u256";
 
+        /// <inheritdoc/>
         public override int TypeSize => 32;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -33,6 +55,7 @@ public override void CreateFromJson(string str)
             Create(bytes);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             // make sure it is unsigned we add 00 at the end
@@ -50,13 +73,14 @@ public override void Create(byte[] byteArray)
             }
             else
             {
-                throw new Exception($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
+                throw new NotSupportedException($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
             }
 
             Bytes = byteArray;
             Value = new BigInteger(byteArray);
         }
 
+        /// <inheritdoc/>
         public override void Create(BigInteger value)
         {
             // Ensure we have a positive number
@@ -67,7 +91,7 @@ public override void Create(BigInteger value)
 
             if (byteArray.Length > TypeSize)
             {
-                throw new Exception($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
+                throw new NotSupportedException($"Wrong byte array size for {TypeName()}, max. {TypeSize} bytes!");
             }
 
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/U32.cs b/Substrate.NetApi/Model/Types/Primitive/U32.cs
index 074d4e6..67d129a 100644
--- a/Substrate.NetApi/Model/Types/Primitive/U32.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/U32.cs
@@ -2,29 +2,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// U32
+    /// </summary>
     public class U32 : BasePrim<uint>
     {
+        /// <summary>
+        /// Explicitly cast a uint to a U32
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator U32(uint p) => new U32(p);
 
+        /// <summary>
+        /// Implicitly cast a U32 to a uint
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator uint(U32 p) => p.Value;
 
+        /// <summary>
+        /// U32 Constructor
+        /// </summary>
         public U32()
         { }
 
+        /// <summary>
+        /// U32 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public U32(uint value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "u32";
 
+        /// <inheritdoc/>
         public override int TypeSize => 4;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -34,6 +56,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -47,6 +70,7 @@ public override void Create(byte[] byteArray)
             Value = BitConverter.ToUInt32(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(uint value)
         {
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/U64.cs b/Substrate.NetApi/Model/Types/Primitive/U64.cs
index 479100a..a490d82 100644
--- a/Substrate.NetApi/Model/Types/Primitive/U64.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/U64.cs
@@ -2,29 +2,51 @@
 
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// U64
+    /// </summary>
     public class U64 : BasePrim<ulong>
     {
+        /// <summary>
+        /// Explicitly cast a ulong to a U64
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator U64(ulong p) => new U64(p);
 
+        /// <summary>
+        /// Implicitly cast a U64 to a ulong
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator ulong(U64 p) => p.Value;
 
+        /// <summary>
+        /// U64 Constructor
+        /// </summary>
         public U64()
         { }
 
+        /// <summary>
+        /// U64 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public U64(ulong value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "u64";
 
+        /// <inheritdoc/>
         public override int TypeSize => 8;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void CreateFromJson(string str)
         {
             var bytes = Utils.HexToByteArray(str, true);
@@ -34,6 +56,7 @@ public override void CreateFromJson(string str)
             Create(result);
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             if (byteArray.Length < TypeSize)
@@ -47,6 +70,7 @@ public override void Create(byte[] byteArray)
             Value = BitConverter.ToUInt64(byteArray, 0);
         }
 
+        /// <inheritdoc/>
         public override void Create(ulong value)
         {
             var bytes = new byte[TypeSize];
diff --git a/Substrate.NetApi/Model/Types/Primitive/U8.cs b/Substrate.NetApi/Model/Types/Primitive/U8.cs
index 372ff69..c852056 100644
--- a/Substrate.NetApi/Model/Types/Primitive/U8.cs
+++ b/Substrate.NetApi/Model/Types/Primitive/U8.cs
@@ -1,34 +1,57 @@
 namespace Substrate.NetApi.Model.Types.Primitive
 {
+    /// <summary>
+    /// U8
+    /// </summary>
     public class U8 : BasePrim<byte>
     {
+        /// <summary>
+        /// Explicitly cast a byte to a U8
+        /// </summary>
+        /// <param name="p"></param>
         public static explicit operator U8(byte p) => new U8(p);
 
+        /// <summary>
+        /// Implicitly cast a U8 to a byte
+        /// </summary>
+        /// <param name="p"></param>
         public static implicit operator byte(U8 p) => p.Value;
 
+        /// <summary>
+        /// U8 Constructor
+        /// </summary>
         public U8()
         { }
 
+        /// <summary>
+        /// U8 Constructor
+        /// </summary>
+        /// <param name="value"></param>
         public U8(byte value)
         {
             Create(value);
         }
 
+        /// <inheritdoc/>
         public override string TypeName() => "u8";
 
+        /// <inheritdoc/>
         public override int TypeSize => 1;
 
+        /// <inheritdoc/>
         public override byte[] Encode()
         {
             return Bytes;
         }
 
+        /// <inheritdoc/>
         public override void Create(byte[] byteArray)
         {
             Bytes = byteArray;
             Value = byteArray[0];
         }
 
+        /// <inheritdoc/>
         public override void Create(byte value)
         {
             Bytes = new byte[] { value };
diff --git a/Substrate.NetApi/Modules/Author.cs b/Substrate.NetApi/Modules/Author.cs
index 87015f3..e6140a4 100644
--- a/Substrate.NetApi/Modules/Author.cs
+++ b/Substrate.NetApi/Modules/Author.cs
@@ -10,47 +10,34 @@
 namespace Substrate.NetApi.Modules
 {
     /// <summary>
-    ///   <br />
+    /// Author Module
     /// </summary>
     public class Author : IAuthor
     {
-        /// <summary>The client</summary>
         private readonly SubstrateClient _client;
 
-        /// <summary>Initializes a new instance of the <see cref="Author" /> class.</summary>
-        /// <param name="client">The client.</param>
+        /// <summary>
+        /// Author Module Constructor
+        /// </summary>
+        /// <param name="client"></param>
         internal Author(SubstrateClient client)
         {
             _client = client;
         }
 
-        /// <summary>Pendings the extrinsic asynchronous.</summary>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<Extrinsic[]> PendingExtrinsicAsync()
         {
             return await PendingExtrinsicAsync(CancellationToken.None);
         }
 
-        /// <summary>Pendings the extrinsic asynchronous.</summary>
-        /// <param name="token">The token.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<Extrinsic[]> PendingExtrinsicAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<Extrinsic[]>("author_pendingExtrinsics", null, token);
         }
 
-        /// <summary>Submits the extrinsic asynchronous.</summary>
-        /// <param name="callArguments">The call arguments.</param>
-        /// <param name="account">The account.</param>
-        /// <param name="tip">The tip.</param>
-        /// <param name="lifeTime">The life time.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<Hash> SubmitExtrinsicAsync(Method method, Account account, ChargeType charge, uint lifeTime)
         {
             var extrinsic = await _client.GetExtrinsicParametersAsync(method, account, charge, lifeTime, signed: true, CancellationToken.None);
@@ -58,6 +45,7 @@ public async Task<Hash> SubmitExtrinsicAsync(Method method, Account account, Cha
             return await SubmitExtrinsicAsync(Utils.Bytes2HexString(extrinsic.Encode()));
         }
 
+        /// <inheritdoc/>
         public async Task<Hash> SubmitExtrinsicAsync(Method method, Account account, ChargeType charge, uint lifeTime, CancellationToken token)
         {
             var extrinsic = await _client.GetExtrinsicParametersAsync(method, account, charge, lifeTime, signed: true, token);
@@ -65,36 +53,19 @@ public async Task<Hash> SubmitExtrinsicAsync(Method method, Account account, Cha
             return await SubmitExtrinsicAsync(Utils.Bytes2HexString(extrinsic.Encode()), token);
         }
 
-        /// <summary>Submits the extrinsic asynchronous.</summary>
-        /// <param name="parameters">The parameters.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<Hash> SubmitExtrinsicAsync(string parameters)
         {
             return await SubmitExtrinsicAsync(parameters, CancellationToken.None);
         }
 
-        /// <summary>Submits the extrinsic asynchronous.</summary>
-        /// <param name="parameters">The parameters.</param>
-        /// <param name="token">The token.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<Hash> SubmitExtrinsicAsync(string parameters, CancellationToken token)
         {
             return await _client.InvokeAsync<Hash>("author_submitExtrinsic", new object[] { parameters }, token);
         }
 
-        /// <summary>Submits the and watch extrinsic asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="callArguments">The call arguments.</param>
-        /// <param name="account">The account.</param>
-        /// <param name="tip">The tip.</param>
-        /// <param name="lifeTime">The life time.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicStatus> callback,
             Method method, Account account, ChargeType charge, uint lifeTime)
         {
@@ -103,15 +74,7 @@ public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicS
             return await SubmitAndWatchExtrinsicAsync(callback, Utils.Bytes2HexString(extrinsic.Encode()));
         }
 
-        /// <summary>Submits the and watch extrinsic asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="callArguments">The call arguments.</param>
-        /// <param name="account">The account.</param>
-        /// <param name="tip">The tip.</param>
-        /// <param name="lifeTime">The life time.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicStatus> callback,
             Method method, Account account, ChargeType charge, uint lifeTime, CancellationToken token)
         {
@@ -120,25 +83,14 @@ public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicS
             return await SubmitAndWatchExtrinsicAsync(callback, extrinsicHex);
         }
 
-        /// <summary>Submits the and watch extrinsic asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="parameters">The parameters.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicStatus> callback,
             string parameters)
         {
             return await SubmitAndWatchExtrinsicAsync(callback, parameters, CancellationToken.None);
         }
 
-        /// <summary>Submits the and watch extrinsic asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="parameters">The parameters.</param>
-        /// <param name="token">The token.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicStatus> callback,
             string parameters, CancellationToken token)
         {
@@ -148,22 +100,13 @@ public async Task<string> SubmitAndWatchExtrinsicAsync(Action<string, ExtrinsicS
             return subscriptionId;
         }
 
-        /// <summary>Unwatches the extrinsic asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<bool> UnwatchExtrinsicAsync(string subscriptionId)
         {
             return await UnwatchExtrinsicAsync(subscriptionId, CancellationToken.None);
         }
 
-        /// <summary>Unwatches the extrinsic asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <param name="token">The token.</param>
-        /// <returns>
-        ///   <br />
-        /// </returns>
+        /// <inheritdoc/>
         public async Task<bool> UnwatchExtrinsicAsync(string subscriptionId, CancellationToken token)
         {
             var result =
diff --git a/Substrate.NetApi/Modules/Chain.cs b/Substrate.NetApi/Modules/Chain.cs
index 46272c8..0d7159c 100644
--- a/Substrate.NetApi/Modules/Chain.cs
+++ b/Substrate.NetApi/Modules/Chain.cs
@@ -8,74 +8,59 @@
 namespace Substrate.NetApi.Modules
 {
     /// <summary>
-    ///   <br />
+    /// Chain Module
     /// </summary>
     public class Chain : IChain
     {
-        /// <summary>The client.</summary>
         private readonly SubstrateClient _client;
 
-        /// <summary>Initializes a new instance of the <see cref="Chain" /> class.</summary>
-        /// <param name="client">The client.</param>
+        /// <summary>
+        /// Chain Module Constructor
+        /// </summary>
+        /// <param name="client"></param>
         internal Chain(SubstrateClient client)
         {
             _client = client;
         }
 
-        /// <summary>Gets the header asynchronous.</summary>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<Header> GetHeaderAsync(CancellationToken token)
         {
             return await GetHeaderAsync(null, token);
         }
 
-        /// <summary>Gets the header asynchronous.</summary>
-        /// <param name="hash">The hash.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<Header> GetHeaderAsync(Hash hash = null)
         {
             return await GetHeaderAsync(hash, CancellationToken.None);
         }
 
-        /// Get header of a relay chain block.
+        /// <inheritdoc/>
         public async Task<Header> GetHeaderAsync(Hash hash, CancellationToken token)
         {
             var parameter = hash != null ? hash.Value : null;
             return await _client.InvokeAsync<Header>("chain_getHeader", new object[] { parameter }, token);
         }
 
-        /// <summary> Gets block asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> The block. </returns>
+        /// <inheritdoc/>
         public async Task<BlockData> GetBlockAsync()
         {
             return await GetBlockAsync(null, CancellationToken.None);
         }
 
-        /// <summary> Gets block asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The block. </returns>
+        /// <inheritdoc/>
         public async Task<BlockData> GetBlockAsync(CancellationToken token)
         {
             return await GetBlockAsync(null, token);
         }
 
-        /// <summary> Gets block asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="hash"> The hash. </param>
-        /// <returns> The block. </returns>
+        /// <inheritdoc/>
         public async Task<BlockData> GetBlockAsync(Hash hash)
         {
             return await GetBlockAsync(hash, CancellationToken.None);
         }
 
-        /// <summary> Gets block asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="hash">  The hash. </param>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The block. </returns>
+        /// <inheritdoc/>
         public async Task<BlockData> GetBlockAsync(Hash hash, CancellationToken token)
         {
             var parameter = hash != null ? hash.Value : null;
@@ -84,67 +69,51 @@ public async Task<BlockData> GetBlockAsync(Hash hash, CancellationToken token)
             return result;
         }
 
-        /// <summary> Gets block hash asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> The block hash. </returns>
+        /// <inheritdoc/>
         public async Task<Hash> GetBlockHashAsync()
         {
             return await GetBlockHashAsync(CancellationToken.None);
         }
 
-        /// <summary> Gets block hash asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="BlockNumber"> The block number. </param>
-        /// <returns> The block hash. </returns>
+
+        /// <inheritdoc/>
         public async Task<Hash> GetBlockHashAsync(BlockNumber blockNumber)
         {
             return await GetBlockHashAsync(blockNumber, CancellationToken.None);
         }
 
-        /// <summary> Gets block hash asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The block hash. </returns>
+        /// <inheritdoc/>
         public async Task<Hash> GetBlockHashAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<Hash>("chain_getBlockHash", new object[] { null }, token);
         }
 
-        /// <summary> Gets block hash asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="blockNumber"> The block number. </param>
-        /// <param name="token">       A token that allows processing to be cancelled. </param>
-        /// <returns> The block hash. </returns>
+        /// <inheritdoc/>
         public async Task<Hash> GetBlockHashAsync(BlockNumber blockNumber, CancellationToken token)
         {
             return await _client.InvokeAsync<Hash>("chain_getBlockHash",
                 new object[] { Utils.Bytes2HexString(blockNumber.Encode()) }, token);
         }
 
-        /// Get hash of the last finalized block in the canon chain.
+        /// <inheritdoc/>
         public async Task<Hash> GetFinalizedHeadAsync()
         {
             return await GetFinalizedHeadAsync(CancellationToken.None);
         }
 
-        /// Get hash of the last finalized block in the canon chain.
+        /// <inheritdoc/>
         public async Task<Hash> GetFinalizedHeadAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<Hash>("chain_getFinalizedHead", null, token);
         }
 
-        /// <summary>Subscribes all heads asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> SubscribeAllHeadsAsync(Action<string, Header> callback)
         {
             return await SubscribeAllHeadsAsync(callback, CancellationToken.None);
         }
 
-        /// <summary>Subscribes all heads asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> SubscribeAllHeadsAsync(Action<string, Header> callback, CancellationToken token)
         {
             var subscriptionId = await _client.InvokeAsync<string>("chain_subscribeAllHeads", null, token);
@@ -152,18 +121,13 @@ public async Task<string> SubscribeAllHeadsAsync(Action<string, Header> callback
             return subscriptionId;
         }
 
-        /// <summary>Unsubscribes all heads asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeAllHeadsAsync(string subscriptionId)
         {
             return await UnsubscribeAllHeadsAsync(subscriptionId, CancellationToken.None);
         }
 
-        /// <summary>Unsubscribes all heads asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeAllHeadsAsync(string subscriptionId, CancellationToken token)
         {
             var result =
@@ -172,18 +136,13 @@ public async Task<bool> UnsubscribeAllHeadsAsync(string subscriptionId, Cancella
             return result;
         }
 
-        /// <summary>Subscribes the new heads asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> SubscribeNewHeadsAsync(Action<string, Header> callback)
         {
             return await SubscribeNewHeadsAsync(callback, CancellationToken.None);
         }
 
-        /// <summary>Subscribes the new heads asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> SubscribeNewHeadsAsync(Action<string, Header> callback, CancellationToken token)
         {
             var subscriptionId = await _client.InvokeAsync<string>("chain_subscribeNewHeads", null, token);
@@ -191,18 +150,13 @@ public async Task<string> SubscribeNewHeadsAsync(Action<string, Header> callback
             return subscriptionId;
         }
 
-        /// <summary>Unubscribes the new heads asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> UnubscribeNewHeadsAsync(string subscriptionId)
         {
             return await UnsubscribeNewHeadsAsync(subscriptionId, CancellationToken.None);
         }
 
-        /// <summary>Unsubscribes the new heads asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeNewHeadsAsync(string subscriptionId, CancellationToken token)
         {
             var result =
@@ -211,18 +165,13 @@ public async Task<bool> UnsubscribeNewHeadsAsync(string subscriptionId, Cancella
             return result;
         }
 
-        /// <summary>Subscribes the finalized heads asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> SubscribeFinalizedHeadsAsync(Action<string, Header> callback)
         {
             return await SubscribeFinalizedHeadsAsync(callback, CancellationToken.None);
         }
 
-        /// <summary>Subscribes the finalized heads asynchronous.</summary>
-        /// <param name="callback">The callback.</param>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> SubscribeFinalizedHeadsAsync(Action<string, Header> callback, CancellationToken token)
         {
             var subscriptionId = await _client.InvokeAsync<string>("chain_subscribeFinalizedHeads", null, token);
@@ -230,18 +179,13 @@ public async Task<string> SubscribeFinalizedHeadsAsync(Action<string, Header> ca
             return subscriptionId;
         }
 
-        /// <summary>Unsubscribes the finalized heads asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeFinalizedHeadsAsync(string subscriptionId)
         {
             return await UnsubscribeFinalizedHeadsAsync(subscriptionId, CancellationToken.None);
         }
 
-        /// <summary>Unsubscribes the finalized heads asynchronous.</summary>
-        /// <param name="subscriptionId">The subscription identifier.</param>
-        /// <param name="token">The token.</param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeFinalizedHeadsAsync(string subscriptionId, CancellationToken token)
         {
             var result = await _client.InvokeAsync<bool>("chain_unsubscribeFinalizedHeads",
diff --git a/Substrate.NetApi/Modules/Contracts/IAuthor.cs b/Substrate.NetApi/Modules/Contracts/IAuthor.cs
index 14bbe5b..a9c16e7 100644
--- a/Substrate.NetApi/Modules/Contracts/IAuthor.cs
+++ b/Substrate.NetApi/Modules/Contracts/IAuthor.cs
@@ -8,6 +8,9 @@
 
 namespace Substrate.NetApi.Modules.Contracts
 {
+    /// <summary>
+    /// Author Module Interface
+    /// </summary>
     public interface IAuthor
     {
         /// <summary>
diff --git a/Substrate.NetApi/Modules/Contracts/IChain.cs b/Substrate.NetApi/Modules/Contracts/IChain.cs
index 9a7fe41..e26eceb 100644
--- a/Substrate.NetApi/Modules/Contracts/IChain.cs
+++ b/Substrate.NetApi/Modules/Contracts/IChain.cs
@@ -6,6 +6,9 @@
 
 namespace Substrate.NetApi.Modules.Contracts
 {
+    /// <summary>
+    /// Chain Module Interface
+    /// </summary>
     public interface IChain
     {
         /// <summary>
diff --git a/Substrate.NetApi/Modules/Contracts/IPayment.cs b/Substrate.NetApi/Modules/Contracts/IPayment.cs
index 65c6bd8..649af5a 100644
--- a/Substrate.NetApi/Modules/Contracts/IPayment.cs
+++ b/Substrate.NetApi/Modules/Contracts/IPayment.cs
@@ -5,6 +5,9 @@
 
 namespace Substrate.NetApi.Modules.Contracts
 {
+    /// <summary>
+    /// Payment Module Interface
+    /// </summary>
     public interface IPayment
     {
         /// <summary>
diff --git a/Substrate.NetApi/Modules/Contracts/IState.cs b/Substrate.NetApi/Modules/Contracts/IState.cs
index 0d80038..ca7d3b4 100644
--- a/Substrate.NetApi/Modules/Contracts/IState.cs
+++ b/Substrate.NetApi/Modules/Contracts/IState.cs
@@ -9,300 +9,334 @@
 
 namespace Substrate.NetApi.Modules.Contracts
 {
+    /// <summary>
+    /// State Module Interface
+    /// </summary>
     public interface IState
     {
         /// <summary>
-        /// Returns the keys with prefix from a child storage with pagination support
+        /// Asynchronously retrieves a paged list of keys from the state with a specified prefix.
         /// </summary>
-        /// <param name="keyPrefix"></param>
-        /// <param name="pageCount"></param>
-        /// <param name="startKey"></param>
-        /// <returns></returns>
+        /// <param name="keyPrefix">The byte array representing the key prefix to query.</param>
+        /// <param name="pageCount">The number of pages to retrieve.</param>
+        /// <param name="startKey">The starting key for pagination, if any.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a JArray of keys.</returns>
         Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey);
 
         /// <summary>
-        /// Returns the keys with prefix from a child storage with pagination support
+        /// Asynchronously retrieves a paged list of keys from the state with a specified prefix, using a cancellation token.
         /// </summary>
-        /// <param name="keyPrefix"></param>
-        /// <param name="pageCount"></param>
-        /// <param name="startKey"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="keyPrefix">The byte array representing the key prefix to query.</param>
+        /// <param name="pageCount">The number of pages to retrieve.</param>
+        /// <param name="startKey">The starting key for pagination, if any.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a JArray of keys.</returns>
         Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, CancellationToken token);
 
         /// <summary>
-        /// Returns the keys with prefix from a child storage with pagination support at specific block
+        /// Asynchronously retrieves a paged list of keys from the state with a specified prefix at a specific block hash.
         /// </summary>
-        /// <param name="keyPrefix"></param>
-        /// <param name="blockHash"></param>
-        /// <param name="pageCount"></param>
-        /// <param name="startKey"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<JArray> GetKeysPagedAtAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, byte[] blockHash, CancellationToken token);
-
-        Task<JArray> GetKeysPagedAtAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, string blockHash, CancellationToken token);
+        /// <param name="keyPrefix">The byte array representing the key prefix to query.</param>
+        /// <param name="pageCount">The number of pages to retrieve.</param>
+        /// <param name="startKey">The starting key for pagination, if any.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a JArray of keys at the specified block.</returns>
+        Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, byte[] blockHash, CancellationToken token);
 
         /// <summary>
-        /// Returns the runtime metadata
+        /// Asynchronously retrieves the metadata of the blockchain state.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>A task that represents the asynchronous operation and returns the metadata as a string.</returns>
         Task<string> GetMetaDataAsync();
 
         /// <summary>
-        /// Returns the runtime metadata
+        /// Asynchronously retrieves the metadata of the blockchain state with a cancellation token.
         /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the metadata as a string.</returns>
         Task<string> GetMetaDataAsync(CancellationToken token);
 
         /// <summary>
-        /// Returns the runtime metadata at specific block
+        /// Asynchronously retrieves the metadata of the blockchain state at a specific block hash.
         /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<string> GetMetaDataAtAsync(byte[] blockHash, CancellationToken token);
+        /// <param name="blockHash">The block hash to query the metadata at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the metadata as a string at the specified block.</returns>
+        Task<string> GetMetaDataAsync(byte[] blockHash, CancellationToken token);
 
-        Task<string> GetMetaDataAtAsync(string blockHash, CancellationToken token);
 
         /// <summary>
-        /// Returns the keys with prefix, leave empty to get all the keys
+        /// Asynchronously retrieves key-value pairs from the state with a specified prefix.
         /// </summary>
-        /// <param name="keyPrefix"></param>
-        /// <returns></returns>
+        /// <param name="keyPrefix">The byte array representing the key prefix.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a JArray of key-value pairs.</returns>
         Task<JArray> GetPairsAsync(byte[] keyPrefix);
 
         /// <summary>
-        /// Returns the keys with prefix, leave empty to get all the keys
+        /// Asynchronously retrieves key-value pairs from the state with a specified prefix and a cancellation token.
         /// </summary>
-        /// <param name="keyPrefix"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="keyPrefix">The byte array representing the key prefix.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a JArray of key-value pairs.</returns>
         Task<JArray> GetPairsAsync(byte[] keyPrefix, CancellationToken token);
 
         /// <summary>
-        /// Returns the keys with prefix, leave empty to get all the keys at specific block
-        /// </summary>
-        /// <param name="keyPrefix"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<JArray> GetPairsAtAsync(byte[] keyPrefix, byte[] blockHash, CancellationToken token);
-
-        Task<JArray> GetPairsAtAsync(byte[] keyPrefix, string blockHash, CancellationToken token);
-
-        /// <summary>
-        /// Get storage from given parameter
+        /// Asynchronously retrieves key-value pairs from the state with a specified prefix at a specific block hash.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[]> keysList, string fromBlock, string toBlock);
+        /// <param name="keyPrefix">The byte array representing the key prefix.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a JArray of key-value pairs at the specified block.</returns>
+        Task<JArray> GetPairsAsync(byte[] keyPrefix, byte[] blockHash, CancellationToken token);
 
-        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[]> keysList, string fromBlock, string toBlock, CancellationToken token);
 
         /// <summary>
-        /// Get storage from given parameter at specific block
+        /// Asynchronously retrieves a read-proof for a set of keys in the state.
         /// </summary>
-        /// <param name="keysList"></param>
-        /// <param name="blockHash"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, byte[] blockHash, CancellationToken token);
-
-        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, string blockHash, CancellationToken token);
+        /// <param name="keyPrefixes">A collection of byte arrays representing the keys for which the read-proof is requested.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the read-proof.</returns>
+        Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes);
 
         /// <summary>
-        /// Returns proof of storage entries
+        /// Asynchronously retrieves a read-proof for a set of keys in the state with a cancellation token.
         /// </summary>
-        /// <returns></returns>
-        Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes);
-
+        /// <param name="keyPrefixes">A collection of byte arrays representing the keys for which the read-proof is requested.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the read-proof.</returns>
         Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes, CancellationToken token);
 
         /// <summary>
-        /// Returns proof of storage entries at a specific block state
+        /// Asynchronously retrieves a read-proof for a set of keys in the state at a specific block hash.
         /// </summary>
-        /// <returns></returns>
-        Task<ReadProof> GetReadProofAtAsync(IEnumerable<byte[]> keyPrefixes, byte[] blockHash, CancellationToken token);
+        /// <param name="keyPrefixes">A collection of byte arrays representing the keys for which the read-proof is requested.</param>
+        /// <param name="blockHash">The block hash to query the read-proof at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the read-proof at the specified block.</returns>
+        Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes, byte[] blockHash, CancellationToken token);
 
-        Task<ReadProof> GetReadProofAtAsync(IEnumerable<byte[]> keyPrefixes, string blockHash, CancellationToken token);
 
         /// <summary>
-        /// Get the runtime version
+        /// Asynchronously retrieves the current runtime version of the blockchain.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>A task that represents the asynchronous operation and returns the current runtime version.</returns>
         Task<RuntimeVersion> GetRuntimeVersionAsync();
 
         /// <summary>
-        /// Get the runtime version
+        /// Asynchronously retrieves the current runtime version of the blockchain with a cancellation token.
         /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the current runtime version.</returns>
         Task<RuntimeVersion> GetRuntimeVersionAsync(CancellationToken token);
 
         /// <summary>
-        /// Get the runtime version at specific block
+        /// Asynchronously retrieves the runtime version of the blockchain at a specific block hash.
         /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<RuntimeVersion> GetRuntimeVersionAtAsync(byte[] blockHash, CancellationToken token);
+        /// <param name="blockHash">The block hash to query the runtime version at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the runtime version at the specified block.</returns>
+        Task<RuntimeVersion> GetRuntimeVersionAsync(byte[] blockHash, CancellationToken token);
 
-        Task<RuntimeVersion> GetRuntimeVersionAtAsync(string blockHash, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the storage for a key
+        /// Asynchronously retrieves the storage data for given parameters.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <returns></returns>
+        /// <param name="parameters">The parameters for which the storage data is requested.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage data.</returns>
         Task<object> GetStorageAsync(byte[] parameters);
 
         /// <summary>
-        /// Retrieves the storage for a key
+        /// Asynchronously retrieves the storage data for given parameters with a cancellation token.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="parameters">The parameters for which the storage data is requested.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage data.</returns>
         Task<object> GetStorageAsync(byte[] parameters, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the storage for a key at specific block
+        /// Asynchronously retrieves the storage data for given parameters at a specific block hash.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="blockHash"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<object> GetStorageAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
-
-        Task<object> GetStorageAtAsync(byte[] parameters, string blockHash, CancellationToken token);
+        /// <param name="parameters">The parameters for which the storage data is requested.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage data.</returns>
+        Task<object> GetStorageAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the storage hash
+        /// Asynchronously retrieves the hash of the storage data for a given key.
         /// </summary>
-        /// <param name="key"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="key">The key for which the storage hash is requested.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage hash.</returns>
         Task<Hash> GetStorageHashAsync(byte[] key);
 
+        /// <summary>
+        /// Asynchronously retrieves the hash of the storage data for a given key with a cancellation token.
+        /// </summary>
+        /// <param name="key">The key for which the storage hash is requested.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage hash.</returns>
         Task<Hash> GetStorageHashAsync(byte[] key, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the storage hash at specific block
+        /// Asynchronously retrieves the hash of the storage data for a given key at a specific block hash.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="blockHash"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<Hash> GetStorageHashAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
+        /// <param name="key">The key for which the storage hash is requested.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage hash.</returns>
+        Task<Hash> GetStorageHashAsync(byte[] key, byte[] blockHash, CancellationToken token);
 
-        Task<Hash> GetStorageHashAtAsync(byte[] parameters, string blockHash, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the storage size
+        /// Asynchronously retrieves the storage size for given parameters.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="parameters">The parameters for which the storage size is requested.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage size.</returns>
         Task<U64> GetStorageSizeAsync(byte[] parameters);
 
+        /// <summary>
+        /// Asynchronously retrieves the storage size for given parameters with a cancellation token.
+        /// </summary>
+        /// <param name="parameters">The parameters for which the storage size is requested.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage size.</returns>
         Task<U64> GetStorageSizeAsync(byte[] parameters, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the storage size at specific block
+        /// Asynchronously retrieves the storage size for given parameters at a specific block hash.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<U64> GetStorageSizeAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
-
-        Task<U64> GetStorageSizeAtAsync(byte[] parameters, string blockHash, CancellationToken token);
+        /// <param name="parameters">The parameters for which the storage size is requested.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns the storage size.</returns>
+        Task<U64> GetStorageSizeAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
 
         /// <summary>
-        /// Provides a way to trace the re-execution of a single block
+        /// Asynchronously queries storage changes for a given set of keys within a specified block range.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<object> GetTraceBlockAsync(byte[] parameters, CancellationToken token);
+        /// <param name="keysList">List of keys to query for changes.</param>
+        /// <param name="fromBlock">The starting block hash for the query range.</param>
+        /// <param name="toBlock">The ending block hash for the query range.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a collection of storage change sets.</returns>
+        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[]> keysList, string fromBlock, string toBlock);
 
-        Task<object> GetTraceBlockAsync(byte[] parameters);
+        /// <summary>
+        /// Asynchronously queries storage changes for a given set of keys within a specified block range, with a cancellation token.
+        /// </summary>
+        /// <param name="keysList">List of keys to query for changes.</param>
+        /// <param name="fromBlock">The starting block hash for the query range.</param>
+        /// <param name="toBlock">The ending block hash for the query range.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a collection of storage change sets.</returns>
+        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[]> keysList, string fromBlock, string toBlock, CancellationToken token);
 
         /// <summary>
-        /// Provides a way to trace the re-execution of a single block at specific block
+        /// Asynchronously queries storage changes for a given set of keys at a specific block hash.
         /// </summary>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<object> GetTraceBlockAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
+        /// <param name="keysList">List of keys to query for changes.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a collection of storage change sets at the specified block.</returns>
+        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, byte[] blockHash);
 
-        Task<object> GetTraceBlockAtAsync(byte[] parameters, string blockHash, CancellationToken token);
+        /// <summary>
+        /// Asynchronously queries storage changes for a given set of keys at a specific block hash, with a cancellation token.
+        /// </summary>
+        /// <param name="keysList">List of keys to query for changes.</param>
+        /// <param name="blockHash">The block hash to query at.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and returns a collection of storage change sets at the specified block.</returns>
+        Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, string blockHash, CancellationToken token);
 
         /// <summary>
-        /// Retrieves the runtime version via subscription
+        /// Asynchronously subscribes to updates of the runtime version.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>A task representing the asynchronous operation, returning a subscription ID as a string.</returns>
         Task<string> SubscribeRuntimeVersionAsync();
 
         /// <summary>
-        /// Retrieves the runtime version via subscription
+        /// Asynchronously subscribes to updates of the runtime version with a cancellation token.
         /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning a subscription ID as a string.</returns>
         Task<string> SubscribeRuntimeVersionAsync(CancellationToken token);
 
         /// <summary>
-        /// Retrieves the runtime version via subscription at specific block
+        /// Asynchronously subscribes to updates of the runtime version at a specific block hash.
         /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<string> SubscribeRuntimeVersionAtAsync(byte[] blockHash, CancellationToken token);
-
-        Task<string> SubscribeRuntimeVersionAtAsync(string blockHash, CancellationToken token);
+        /// <param name="blockHash">The block hash to subscribe to.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning a subscription ID as a string.</returns>
+        Task<string> SubscribeRuntimeVersionAsync(byte[] blockHash, CancellationToken token);
 
         /// <summary>
-        /// Subscribes to storage changes for the provided keys
+        /// Asynchronously subscribes to changes in the storage for specified keys.
         /// </summary>
-        /// <param name="keys"></param>
-        /// <param name="callback"></param>
-        /// <returns></returns>
+        /// <param name="keys">A collection of keys to subscribe to.</param>
+        /// <param name="callback">The callback action to invoke on each storage change.</param>
+        /// <returns>A task representing the asynchronous operation, returning a subscription ID as a string.</returns>
         Task<string> SubscribeStorageAsync(JArray keys, Action<string, StorageChangeSet> callback);
 
         /// <summary>
-        /// Subscribes to storage changes for the provided keys
+        /// Asynchronously subscribes to changes in the storage for specified keys, with a cancellation token.
         /// </summary>
-        /// <param name="keys"></param>
-        /// <param name="callback"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="keys">A collection of keys to subscribe to.</param>
+        /// <param name="callback">The callback action to invoke on each storage change.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning a subscription ID as a string.</returns>
         Task<string> SubscribeStorageAsync(JArray keys, Action<string, StorageChangeSet> callback, CancellationToken token);
 
         /// <summary>
-        /// Unsuscribe to given subscription id
+        /// Asynchronously traces a block.
+        /// </summary>
+        /// <param name="parameters">The parameters specifying the block to trace.</param>
+        /// <returns>A task representing the asynchronous operation, returning trace data.</returns>
+        Task<object> GetTraceBlockAsync(byte[] parameters);
+
+        /// <summary>
+        /// Asynchronously traces a block with a cancellation token.
+        /// </summary>
+        /// <param name="parameters">The parameters specifying the block to trace.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning trace data.</returns>
+        Task<object> GetTraceBlockAsync(byte[] parameters, CancellationToken token);
+
+        /// <summary>
+        /// Asynchronously traces a block at a specific block hash.
+        /// </summary>
+        /// <param name="parameters">The parameters specifying the block to trace.</param>
+        /// <param name="blockHash">The block hash to trace.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning trace data at the specified block hash.</returns>
+        Task<object> GetTraceBlockAsync(byte[] parameters, byte[] blockHash, CancellationToken token);
+
+        /// <summary>
+        /// Asynchronously unsubscribes from updates of the runtime version.
         /// </summary>
-        /// <param name="subscriptionId"></param>
-        /// <returns></returns>
+        /// <param name="subscriptionId">The subscription ID to cancel.</param>
+        /// <returns>A task representing the asynchronous operation, returning a boolean indicating success or failure.</returns>
         Task<bool> UnsubscribeRuntimeVersionAsync(string subscriptionId);
 
         /// <summary>
-        /// Unsuscribe to given subscription id
+        /// Asynchronously unsubscribes from updates of the runtime version with a cancellation token.
         /// </summary>
-        /// <param name="subscriptionId"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="subscriptionId">The subscription ID to cancel.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning a boolean indicating success or failure.</returns>
         Task<bool> UnsubscribeRuntimeVersionAsync(string subscriptionId, CancellationToken token);
 
         /// <summary>
-        /// Unsuscribe to given subscription id
+        /// Asynchronously unsubscribes from changes in the storage.
         /// </summary>
-        /// <param name="subscriptionId"></param>
-        /// <returns></returns>
+        /// <param name="subscriptionId">The subscription ID to cancel.</param>
+        /// <returns>A task representing the asynchronous operation, returning a boolean indicating success or failure.</returns>
         Task<bool> UnsubscribeStorageAsync(string subscriptionId);
 
         /// <summary>
-        /// Unsuscribe to given subscription id
+        /// Asynchronously unsubscribes from changes in the storage with a cancellation token.
         /// </summary>
-        /// <param name="subscriptionId"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <param name="subscriptionId">The subscription ID to cancel.</param>
+        /// <param name="token">A cancellation token.</param>
+        /// <returns>A task representing the asynchronous operation, returning a boolean indicating success or failure.</returns>
         Task<bool> UnsubscribeStorageAsync(string subscriptionId, CancellationToken token);
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Modules/Contracts/ISystem.cs b/Substrate.NetApi/Modules/Contracts/ISystem.cs
index 7e79c4c..189e758 100644
--- a/Substrate.NetApi/Modules/Contracts/ISystem.cs
+++ b/Substrate.NetApi/Modules/Contracts/ISystem.cs
@@ -4,6 +4,9 @@
 
 namespace Substrate.NetApi.Modules.Contracts
 {
+    /// <summary>
+    /// System Module Interface
+    /// </summary>
     public interface ISystem
     {
         /// <summary>
diff --git a/Substrate.NetApi/Modules/Contracts/IUnstableCalls.cs b/Substrate.NetApi/Modules/Contracts/IUnstableCalls.cs
index 6e51f2d..7703ca1 100644
--- a/Substrate.NetApi/Modules/Contracts/IUnstableCalls.cs
+++ b/Substrate.NetApi/Modules/Contracts/IUnstableCalls.cs
@@ -8,6 +8,9 @@
 
 namespace Substrate.NetApi.Modules.Contracts
 {
+    /// <summary>
+    /// UnstableCalls Module Interface
+    /// </summary>
     public interface IUnstableCalls
     {
         /// <summary>
diff --git a/Substrate.NetApi/Modules/Payment.cs b/Substrate.NetApi/Modules/Payment.cs
index 6288826..752d1e5 100644
--- a/Substrate.NetApi/Modules/Payment.cs
+++ b/Substrate.NetApi/Modules/Payment.cs
@@ -6,21 +6,23 @@
 
 namespace Substrate.NetApi.Modules
 {
-    /// <summary> A system. </summary>
-    /// <remarks> 19.09.2020. </remarks>
+    /// <summary>
+    /// Payment Module
+    /// </summary>
     public class Payment : IPayment
     {
-        /// <summary> The client. </summary>
         private readonly SubstrateClient _client;
 
-        /// <summary> Constructor. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="client"> The client. </param>
+        /// <summary>
+        /// Payment Module Constructor
+        /// </summary>
+        /// <param name="client"></param>
         internal Payment(SubstrateClient client)
         {
             _client = client;
         }
 
+        /// <inheritdoc/>
         public async Task<FeeDetails> QueryFeeDetailAsync(string extrinsic, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
@@ -31,6 +33,7 @@ public async Task<FeeDetails> QueryFeeDetailAsync(string extrinsic, string block
             return await _client.InvokeAsync<FeeDetails>("payment_queryFeeDetails", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public async Task<RuntimeDispatchInfo> QueryInfoAsync(string extrinsic, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
diff --git a/Substrate.NetApi/Modules/State.cs b/Substrate.NetApi/Modules/State.cs
index 98e669b..ba07df0 100644
--- a/Substrate.NetApi/Modules/State.cs
+++ b/Substrate.NetApi/Modules/State.cs
@@ -12,16 +12,20 @@
 
 namespace Substrate.NetApi.Modules
 {
-    /// <summary> A state. </summary>
-    /// <remarks> 19.09.2020. </remarks>
+    /// <summary>
+    /// State Module
+    /// </summary>
     public class State : IState
     {
-        /// <summary> The client. </summary>
+        /// <summary>
+        /// Substrate client.
+        /// </summary>
         private readonly SubstrateClient _client;
 
-        /// <summary> Constructor. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="client"> The client. </param>
+        /// <summary>
+        /// The state module allows you to interact with the storage of the runtime.
+        /// </summary>
+        /// <param name="client"></param>
         internal State(SubstrateClient client)
         {
             _client = client;
@@ -32,17 +36,21 @@ internal State(SubstrateClient client)
         //state_getChildReadProof
         //state_getKeys
 
+        /// <inheritdoc/>
         public Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey)
             => GetKeysPagedAsync(keyPrefix, pageCount, startKey, CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey,
             CancellationToken token)
-            => GetKeysPagedAtAsync(keyPrefix, pageCount, startKey, string.Empty, token);
+            => GetKeysPagedAsync(keyPrefix, pageCount, startKey, string.Empty, token);
 
-        public Task<JArray> GetKeysPagedAtAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, byte[] blockHash, CancellationToken token)
-            => GetKeysPagedAtAsync(keyPrefix, pageCount, startKey, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, byte[] blockHash, CancellationToken token)
+            => GetKeysPagedAsync(keyPrefix, pageCount, startKey, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<JArray> GetKeysPagedAtAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<JArray> GetKeysPagedAsync(byte[] keyPrefix, uint pageCount, byte[] startKey, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -54,31 +62,39 @@ public async Task<JArray> GetKeysPagedAtAsync(byte[] keyPrefix, uint pageCount,
             return await _client.InvokeAsync<JArray>("state_getKeysPaged", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public Task<string> GetMetaDataAsync()
             => GetMetaDataAsync(CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<string> GetMetaDataAsync(CancellationToken token)
-            => GetMetaDataAtAsync(string.Empty, token);
+            => GetMetaDataAsync(string.Empty, token);
 
-        public Task<string> GetMetaDataAtAsync(byte[] blockHash, CancellationToken token)
-            => GetMetaDataAtAsync(Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<string> GetMetaDataAsync(byte[] blockHash, CancellationToken token)
+            => GetMetaDataAsync(Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<string> GetMetaDataAtAsync(string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<string> GetMetaDataAsync(string blockHash, CancellationToken token)
         {
             var fullParams = new object[] { string.IsNullOrEmpty(blockHash) ? null : blockHash };
             return await _client.InvokeAsync<string>("state_getMetadata", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public Task<JArray> GetPairsAsync(byte[] keyPrefix)
             => GetPairsAsync(keyPrefix, CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<JArray> GetPairsAsync(byte[] keyPrefix, CancellationToken token)
-            => GetPairsAtAsync(keyPrefix, string.Empty, token);
+            => GetPairsAsync(keyPrefix, string.Empty, token);
 
-        public Task<JArray> GetPairsAtAsync(byte[] keyPrefix, byte[] blockHash, CancellationToken token)
-            => GetPairsAtAsync(keyPrefix, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<JArray> GetPairsAsync(byte[] keyPrefix, byte[] blockHash, CancellationToken token)
+            => GetPairsAsync(keyPrefix, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<JArray> GetPairsAtAsync(byte[] keyPrefix, string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<JArray> GetPairsAsync(byte[] keyPrefix, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -89,16 +105,24 @@ public async Task<JArray> GetPairsAtAsync(byte[] keyPrefix, string blockHash, Ca
             return await _client.InvokeAsync<JArray>("state_getPairs", fullParams, token);
         }
 
+
+        /// <inheritdoc/>
         public Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes)
          => GetReadProofAsync(keyPrefixes, CancellationToken.None);
 
+
+        /// <inheritdoc/>
         public Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes, CancellationToken token)
-            => GetReadProofAtAsync(keyPrefixes, string.Empty, token);
+            => GetReadProofAsync(keyPrefixes, string.Empty, token);
+
 
-        public Task<ReadProof> GetReadProofAtAsync(IEnumerable<byte[]> keyPrefixes, byte[] blockHash, CancellationToken token)
-            => GetReadProofAtAsync(keyPrefixes, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes, byte[] blockHash, CancellationToken token)
+            => GetReadProofAsync(keyPrefixes, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<ReadProof> GetReadProofAtAsync(IEnumerable<byte[]> keyPrefixes, string blockHash, CancellationToken token)
+
+        /// <inheritdoc/>
+        public async Task<ReadProof> GetReadProofAsync(IEnumerable<byte[]> keyPrefixes, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -109,16 +133,20 @@ public async Task<ReadProof> GetReadProofAtAsync(IEnumerable<byte[]> keyPrefixes
             return await _client.InvokeAsync<ReadProof>("state_getReadProof", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public Task<RuntimeVersion> GetRuntimeVersionAsync()
             => GetRuntimeVersionAsync(CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<RuntimeVersion> GetRuntimeVersionAsync(CancellationToken token)
-            => GetRuntimeVersionAtAsync(string.Empty, token);
+            => GetRuntimeVersionAsync(string.Empty, token);
 
-        public Task<RuntimeVersion> GetRuntimeVersionAtAsync(byte[] blockHash, CancellationToken token)
-            => GetRuntimeVersionAtAsync(Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<RuntimeVersion> GetRuntimeVersionAsync(byte[] blockHash, CancellationToken token)
+            => GetRuntimeVersionAsync(Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<RuntimeVersion> GetRuntimeVersionAtAsync(string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<RuntimeVersion> GetRuntimeVersionAsync(string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -128,16 +156,20 @@ public async Task<RuntimeVersion> GetRuntimeVersionAtAsync(string blockHash, Can
             return await _client.InvokeAsync<RuntimeVersion>("state_getRuntimeVersion", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public Task<object> GetStorageAsync(byte[] parameters)
             => GetStorageAsync(parameters, CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<object> GetStorageAsync(byte[] parameters, CancellationToken token)
-            => GetStorageAtAsync(parameters, string.Empty, token);
+            => GetStorageAsync(parameters, string.Empty, token);
 
-        public Task<object> GetStorageAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token)
-            => GetStorageAtAsync(parameters, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<object> GetStorageAsync(byte[] parameters, byte[] blockHash, CancellationToken token)
+            => GetStorageAsync(parameters, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<object> GetStorageAtAsync(byte[] parameters, string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<object> GetStorageAsync(byte[] parameters, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -148,16 +180,20 @@ public async Task<object> GetStorageAtAsync(byte[] parameters, string blockHash,
             return await _client.InvokeAsync<object>("state_getStorage", fullParams.ToArray(), token);
         }
 
+        /// <inheritdoc/>
         public Task<Hash> GetStorageHashAsync(byte[] key)
             => GetStorageHashAsync(key, CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<Hash> GetStorageHashAsync(byte[] key, CancellationToken token)
-            => GetStorageHashAtAsync(key, string.Empty, token);
+            => GetStorageHashAsync(key, string.Empty, token);
 
-        public Task<Hash> GetStorageHashAtAsync(byte[] key, byte[] blockHash, CancellationToken token)
-            => GetStorageHashAtAsync(key, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<Hash> GetStorageHashAsync(byte[] key, byte[] blockHash, CancellationToken token)
+            => GetStorageHashAsync(key, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<Hash> GetStorageHashAtAsync(byte[] parameters, string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<Hash> GetStorageHashAsync(byte[] parameters, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -168,16 +204,20 @@ public async Task<Hash> GetStorageHashAtAsync(byte[] parameters, string blockHas
             return await _client.InvokeAsync<Hash>("state_getStorageHash", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public Task<U64> GetStorageSizeAsync(byte[] parameters)
             => GetStorageSizeAsync(parameters, CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<U64> GetStorageSizeAsync(byte[] parameters, CancellationToken token)
-            => GetStorageSizeAtAsync(parameters, string.Empty, token);
+            => GetStorageSizeAsync(parameters, string.Empty, token);
 
-        public Task<U64> GetStorageSizeAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token)
-            => GetStorageSizeAtAsync(parameters, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<U64> GetStorageSizeAsync(byte[] parameters, byte[] blockHash, CancellationToken token)
+            => GetStorageSizeAsync(parameters, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<U64> GetStorageSizeAtAsync(byte[] parameters, string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<U64> GetStorageSizeAsync(byte[] parameters, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -196,9 +236,11 @@ public async Task<U64> GetStorageSizeAtAsync(byte[] parameters, string blockHash
             return resNumber;
         }
 
+        /// <inheritdoc/>
         public Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[]> keysList, string fromBlock, string toBlock)
             => GetQueryStorageAsync(keysList, fromBlock, toBlock, CancellationToken.None);
 
+        /// <inheritdoc/>
         public async Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[]> keysList, string fromBlock, string toBlock, CancellationToken token)
         {
             var fullParams = new object[]
@@ -217,9 +259,16 @@ public async Task<IEnumerable<StorageChangeSet>> GetQueryStorageAsync(List<byte[
             return JsonConvert.DeserializeObject<IEnumerable<StorageChangeSet>>(jArray.ToString());
         }
 
-        public Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, byte[] blockHash, CancellationToken token)
-            => GetQueryStorageAtAsync(keysList, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, byte[] blockHash)
+            => GetQueryStorageAtAsync(keysList, Utils.Bytes2HexString(blockHash));
+
+        /// <inheritdoc/>
+        public Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, string blockHash)
+            => GetQueryStorageAtAsync(keysList, blockHash, CancellationToken.None);
+
 
+        /// <inheritdoc/>
         public async Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byte[]> keysList, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
@@ -237,16 +286,20 @@ public async Task<IEnumerable<StorageChangeSet>> GetQueryStorageAtAsync(List<byt
             return JsonConvert.DeserializeObject<IEnumerable<StorageChangeSet>>(jArray.ToString());
         }
 
+        /// <inheritdoc/>
         public Task<string> SubscribeRuntimeVersionAsync()
             => SubscribeRuntimeVersionAsync(CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<string> SubscribeRuntimeVersionAsync(CancellationToken token)
-            => SubscribeRuntimeVersionAtAsync(string.Empty, token);
+            => SubscribeRuntimeVersionAsync(string.Empty, token);
 
-        public Task<string> SubscribeRuntimeVersionAtAsync(byte[] blockHash, CancellationToken token)
-            => SubscribeRuntimeVersionAtAsync(Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<string> SubscribeRuntimeVersionAsync(byte[] blockHash, CancellationToken token)
+            => SubscribeRuntimeVersionAsync(Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<string> SubscribeRuntimeVersionAtAsync(string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<string> SubscribeRuntimeVersionAsync(string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -256,11 +309,13 @@ public async Task<string> SubscribeRuntimeVersionAtAsync(string blockHash, Cance
             return await _client.InvokeAsync<string>("state_subscribeRuntimeVersion", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public async Task<string> SubscribeStorageAsync(JArray keys, Action<string, StorageChangeSet> callback)
         {
             return await SubscribeStorageAsync(keys, callback, CancellationToken.None);
         }
 
+        /// <inheritdoc/>
         public async Task<string> SubscribeStorageAsync(JArray keys, Action<string, StorageChangeSet> callback,
             CancellationToken token)
         {
@@ -270,16 +325,20 @@ public async Task<string> SubscribeStorageAsync(JArray keys, Action<string, Stor
             return subscriptionId;
         }
 
+        /// <inheritdoc/>
         public Task<object> GetTraceBlockAsync(byte[] parameters)
             => GetTraceBlockAsync(parameters, CancellationToken.None);
 
+        /// <inheritdoc/>
         public Task<object> GetTraceBlockAsync(byte[] parameters, CancellationToken token)
-            => GetTraceBlockAtAsync(parameters, string.Empty, token);
+            => GetTraceBlockAsync(parameters, string.Empty, token);
 
-        public Task<object> GetTraceBlockAtAsync(byte[] parameters, byte[] blockHash, CancellationToken token)
-            => GetTraceBlockAtAsync(parameters, Utils.Bytes2HexString(blockHash), token);
+        /// <inheritdoc/>
+        public Task<object> GetTraceBlockAsync(byte[] parameters, byte[] blockHash, CancellationToken token)
+            => GetTraceBlockAsync(parameters, Utils.Bytes2HexString(blockHash), token);
 
-        public async Task<object> GetTraceBlockAtAsync(byte[] parameters, string blockHash, CancellationToken token)
+        /// <inheritdoc/>
+        public async Task<object> GetTraceBlockAsync(byte[] parameters, string blockHash, CancellationToken token)
         {
             var fullParams = new object[]
             {
@@ -290,22 +349,26 @@ public async Task<object> GetTraceBlockAtAsync(byte[] parameters, string blockHa
             return await _client.InvokeAsync<object>("state_traceBlock", fullParams, token);
         }
 
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeRuntimeVersionAsync(string subscriptionId)
         {
             return await UnsubscribeRuntimeVersionAsync(subscriptionId, CancellationToken.None);
         }
 
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeRuntimeVersionAsync(string subscriptionId, CancellationToken token)
         {
             return await _client.InvokeAsync<bool>("state_unsubscribeRuntimeVersion", new object[] { subscriptionId },
                 token);
         }
 
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeStorageAsync(string subscriptionId)
         {
             return await UnsubscribeStorageAsync(subscriptionId, CancellationToken.None);
         }
 
+        /// <inheritdoc/>
         public async Task<bool> UnsubscribeStorageAsync(string subscriptionId, CancellationToken token)
         {
             return await _client.InvokeAsync<bool>("state_unsubscribeStorage", new object[] { subscriptionId }, token);
diff --git a/Substrate.NetApi/Modules/System.cs b/Substrate.NetApi/Modules/System.cs
index 440697f..328aac7 100644
--- a/Substrate.NetApi/Modules/System.cs
+++ b/Substrate.NetApi/Modules/System.cs
@@ -6,270 +6,172 @@
 
 namespace Substrate.NetApi.Modules
 {
-    /// <summary> A system. </summary>
-    /// <remarks> 19.09.2020. </remarks>
+    /// <summary>
+    /// System Module
+    /// </summary>
     public class System : ISystem
     {
-        /// <summary> The client. </summary>
+
         private readonly SubstrateClient _client;
 
-        /// <summary> Constructor. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="client"> The client. </param>
+        /// <summary>
+        /// System Module Constructor
+        /// </summary>
+        /// <param name="client"></param>
         internal System(SubstrateClient client)
         {
             _client = client;
         }
 
-        /// <summary>
-        /// Account Next Index
-        /// </summary>
-        /// <param name="address"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<uint> AccountNextIndexAsync(string address, CancellationToken token)
         {
             return await _client.InvokeAsync<uint>("system_accountNextIndex", new object[] { address }, token);
         }
 
-        /// <summary>
-        /// Add log filter (-32601: RPC call is unsafe to be called externally)
-        /// </summary>
-        /// <param name="directives"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<object> AddLogFilterAsync(string directives, CancellationToken token)
         {
             throw new NotImplementedException();
             //return await _client.InvokeAsync<uint>("system_addLogFilter", new object[] { directives }, token);
         }
 
-        /// <summary>
-        /// Add reserved peer filter (-32601: RPC call is unsafe to be called externally)
-        /// </summary>
-        /// <param name="peer"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<object> AddReservedPeerAsync(string peer, CancellationToken token)
         {
             throw new NotImplementedException();
             //return await _client.InvokeAsync<uint>("system_addReservedPeer", new object[] { peer }, token);
         }
 
-        /// <summary> Chain asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> The chain. </returns>
+        /// <inheritdoc/>
         public async Task<string> ChainAsync()
         {
             return await ChainAsync(CancellationToken.None);
         }
 
-        /// <summary> Chain asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The chain. </returns>
+        /// <inheritdoc/>
         public async Task<string> ChainAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string>("system_chain", null, token);
         }
 
-        /// <summary> Chain type asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> The chain type. </returns>
+        /// <inheritdoc/>
         public async Task<string> ChainTypeAsync()
         {
             return await ChainTypeAsync(CancellationToken.None);
         }
 
-        /// <summary> Chain Type asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The chain type . </returns>
+        /// <inheritdoc/>
         public async Task<string> ChainTypeAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string>("system_chainType", null, token);
         }
 
-        /// <summary>
-        /// Dry run
-        /// </summary>
-        /// <param name="extrinsicHex"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<object> DryRunAsync(string extrinsicHex, CancellationToken token)
         {
             throw new NotImplementedException();
             //return await _client.InvokeAsync<string>("system_dryRun", new object[] { extrinsicHex }, token);
         }
 
-        /// <summary>
-        /// Dry run at
-        /// </summary>
-        /// <param name="extrinsicHex"></param>
-        /// <param name="blockHashHex"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<string> DryRunAtAsync(string extrinsicHex, string blockHashHex, CancellationToken token)
         {
             throw new NotImplementedException();
             //return await _client.InvokeAsync<string>("system_dryRunAt", new object[] { extrinsicHex, blockHashHex }, token);
         }
 
-        /// <summary>
-        /// Health
-        /// </summary>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<Health> HealthAsync()
         {
             return await HealthAsync(CancellationToken.None);
         }
 
-        /// <summary>
-        /// Health
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<Health> HealthAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<Health>("system_health", null, token);
         }
 
-        /// <summary>
-        /// Local listen addresses
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string[]> LocalListenAddressesAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string[]>("system_localListenAddresses", null, token);
         }
 
-        /// <summary>
-        /// Local peer id
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> LocalPeerIdAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string>("system_localPeerId", null, token);
         }
 
-        /// <summary> Name asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> The name. </returns>
+        /// <inheritdoc/>
         public async Task<string> NameAsync()
         {
             return await NameAsync(CancellationToken.None);
         }
 
-        /// <summary> Name asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The name. </returns>
+        /// <inheritdoc/>
         public async Task<string> NameAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string>("system_name", null, token);
         }
 
-        /// <summary>
-        /// Node roles
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string[]> NodeRolesAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string[]>("system_nodeRoles", null, token);
         }
 
-        /// <summary>
-        /// Peers
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<object> PeersAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<object>("system_peers", null, token);
         }
 
-        /// <summary>
-        /// Properties
-        /// </summary>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<Properties> PropertiesAsync()
         {
             return await PropertiesAsync(CancellationToken.None);
         }
 
-        /// <summary>
-        /// Properties
-        /// </summary>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<Properties> PropertiesAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<Properties>("system_properties", null, token);
         }
 
-        /// <summary>
-        /// Remove reserved peer
-        /// </summary>
-        /// <param name="peerId"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<object> RemoveReservedPeerAsync(string peerId, CancellationToken token)
         {
             return await _client.InvokeAsync<object>("system_removeReservedPeer", new object[] { peerId }, token);
         }
 
-        /// <summary>
-        /// Reserved peers
-        /// </summary>
-        /// <param name="peerId"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<object> ReservedPeersAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<object>("system_reservedPeers", null, token);
         }
 
-        /// <summary>
-        /// Reset log filter
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        /// <exception cref="NotImplementedException"></exception>
+        /// <inheritdoc/>
         public async Task<object> ResetLogFilterAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<object>("system_resetLogFilter", null, token);
         }
 
-        /// <summary>
-        /// Sync state
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<SyncState> SyncStateAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<SyncState>("system_syncState", null, token);
         }
 
-        /// <summary> Version asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> The version. </returns>
+        /// <inheritdoc/>
         public async Task<string> VersionAsync()
         {
             return await VersionAsync(CancellationToken.None);
         }
 
-        /// <summary> Version asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> The version. </returns>
+        /// <inheritdoc/>
         public async Task<string> VersionAsync(CancellationToken token)
         {
             return await _client.InvokeAsync<string>("system_version", null, token);
diff --git a/Substrate.NetApi/Modules/UnstableCalls.cs b/Substrate.NetApi/Modules/UnstableCalls.cs
index 421896c..d8901bf 100644
--- a/Substrate.NetApi/Modules/UnstableCalls.cs
+++ b/Substrate.NetApi/Modules/UnstableCalls.cs
@@ -9,7 +9,7 @@
 namespace Substrate.NetApi.Modules
 {
     /// <summary>
-    /// New Api 2
+    /// UnstableCalls Module
     /// </summary>
     public class UnstableCalls : IUnstableCalls
     {
@@ -17,7 +17,7 @@ public class UnstableCalls : IUnstableCalls
         private readonly SubstrateClient _client;
 
         /// <summary>
-        /// New Api 2
+        /// UnstableCalls Module Constructor
         /// </summary>
         /// <param name="client"></param>
         internal UnstableCalls(SubstrateClient client)
@@ -25,15 +25,7 @@ internal UnstableCalls(SubstrateClient client)
             _client = client;
         }
 
-        /// <summary>
-        /// Transaction Unstable Submit And Watch Async
-        /// </summary>
-        /// <param name="callback"></param>
-        /// <param name="method"></param>
-        /// <param name="account"></param>
-        /// <param name="charge"></param>
-        /// <param name="lifeTime"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string, TransactionEventInfo> callback, Method method, Account account, ChargeType charge, uint lifeTime)
         {
             var extrinsic = await _client.GetExtrinsicParametersAsync(method, account, charge, lifeTime, signed: true, CancellationToken.None);
@@ -41,16 +33,7 @@ public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string,
             return await TransactionUnstableSubmitAndWatchAsync(callback, Utils.Bytes2HexString(extrinsic.Encode()));
         }
 
-        /// <summary>
-        /// Transaction Unstable Submit And Watch Async
-        /// </summary>
-        /// <param name="callback"></param>
-        /// <param name="method"></param>
-        /// <param name="account"></param>
-        /// <param name="charge"></param>
-        /// <param name="lifeTime"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string, TransactionEventInfo> callback, Method method, Account account, ChargeType charge, uint lifeTime, CancellationToken token)
         {
             var extrinsic = await _client.GetExtrinsicParametersAsync(method, account, charge, lifeTime, signed: true, token);
@@ -58,24 +41,13 @@ public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string,
             return await TransactionUnstableSubmitAndWatchAsync(callback, extrinsicHex);
         }
 
-        /// <summary>
-        /// Transaction Unstable Submit And Watch Async
-        /// </summary>
-        /// <param name="callback"></param>
-        /// <param name="parameters"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string, TransactionEventInfo> callback, string parameters)
         {
             return await TransactionUnstableSubmitAndWatchAsync(callback, parameters, CancellationToken.None);
         }
 
-        /// <summary>
-        /// Transaction Unstable Submit And Watch Async
-        /// </summary>
-        /// <param name="callback"></param>
-        /// <param name="parameters"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string, TransactionEventInfo> callback, string parameters, CancellationToken token)
         {
             var subscriptionId =
@@ -84,22 +56,13 @@ public async Task<string> TransactionUnstableSubmitAndWatchAsync(Action<string,
             return subscriptionId;
         }
 
-        /// <summary>
-        /// Transaction Unstable Unwatch Async
-        /// </summary>
-        /// <param name="subscriptionId"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> TransactionUnstableUnwatchAsync(string subscriptionId)
         {
             return await TransactionUnstableUnwatchAsync(subscriptionId, CancellationToken.None);
         }
 
-        /// <summary>
-        /// Transaction Unstable Unwatch Async
-        /// </summary>
-        /// <param name="subscriptionId"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
+        /// <inheritdoc/>
         public async Task<bool> TransactionUnstableUnwatchAsync(string subscriptionId, CancellationToken token)
         {
             var result =
diff --git a/Substrate.NetApi/Sign/WrapMessage.cs b/Substrate.NetApi/Sign/WrapMessage.cs
index fe0d2f8..8c9fa0a 100644
--- a/Substrate.NetApi/Sign/WrapMessage.cs
+++ b/Substrate.NetApi/Sign/WrapMessage.cs
@@ -34,6 +34,12 @@ public static bool IsWrapped(byte[] data)
                 (data.Take(U8A_WRAP_PREFIX.Length).SequenceEqual(U8A_WRAP_PREFIX) &&
                 data.Skip(data.Length - U8A_WRAP_POSTFIX.Length).Take(U8A_WRAP_POSTFIX.Length).SequenceEqual(U8A_WRAP_POSTFIX));
         }
+
+        /// <summary>
+        /// Check if data is wrapped by <see cref="U8A_WRAP_PREFIX_STR"/> and <see cref="U8A_WRAP_POSTFIX_STR"/>
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
         public static bool IsWrapped(string data) => IsWrapped(Encoding.UTF8.GetBytes(data));
 
         /// <summary>
@@ -55,6 +61,12 @@ public static byte[] Unwrap(byte[] data)
                     .ToArray() :
                 data;
         }
+
+        /// <summary>
+        /// Unwrap data from <see cref="U8A_WRAP_PREFIX_STR"/> and <see cref="U8A_WRAP_POSTFIX_STR"/>
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
         public static byte[] Unwrap(string data) => Unwrap(Encoding.UTF8.GetBytes(data));
 
         /// <summary>
@@ -76,6 +88,12 @@ public static byte[] Wrap(byte[] data)
                 .Concat(U8A_WRAP_POSTFIX)
                 .ToArray();
         }
+
+        /// <summary>
+        /// Wrap data with <see cref="U8A_WRAP_PREFIX_STR"/> and <see cref="U8A_WRAP_POSTFIX_STR"/>
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
         public static byte[] Wrap(string data) => Wrap(Encoding.UTF8.GetBytes(data));
     }
 }
diff --git a/Substrate.NetApi/SubscriptionListener.cs b/Substrate.NetApi/SubscriptionListener.cs
index 6771cad..3299038 100644
--- a/Substrate.NetApi/SubscriptionListener.cs
+++ b/Substrate.NetApi/SubscriptionListener.cs
@@ -7,8 +7,12 @@
 
 namespace Substrate.NetApi
 {
+    /// <summary>
+    /// Subscription Listener
+    /// </summary>
     public class SubscriptionListener
     {
+
         /// <summary> The logger. </summary>
         private static readonly ILogger Logger = new LoggerConfiguration().CreateLogger();
 
diff --git a/Substrate.NetApi/Substrate.NetApi.csproj b/Substrate.NetApi/Substrate.NetApi.csproj
index 37dce1f..67e2ed8 100644
--- a/Substrate.NetApi/Substrate.NetApi.csproj
+++ b/Substrate.NetApi/Substrate.NetApi.csproj
@@ -3,7 +3,7 @@
 	<PropertyGroup>
 		<PackageId>Substrate.NET.API</PackageId>
 		<TargetFrameworks>netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
-		<Version>0.9.14</Version>
+		<Version>0.9.15</Version>
 		<Company>Substrate Gaming</Company>
 		<Authors>Substrate Gaming</Authors>
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
@@ -12,6 +12,8 @@
 		<PackageLicenseFile>LICENSE</PackageLicenseFile>
 		<RepositoryUrl>https://github.com/SubstrateGaming/Substrate.NET.API</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
+		<GenerateDocumentationFile>true</GenerateDocumentationFile>
+		<DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/Substrate.NetApi/SubstrateClient.cs b/Substrate.NetApi/SubstrateClient.cs
index bdb1fd0..e0e98f7 100644
--- a/Substrate.NetApi/SubstrateClient.cs
+++ b/Substrate.NetApi/SubstrateClient.cs
@@ -56,11 +56,14 @@ public class SubstrateClient : IDisposable
         /// <summary>
         /// Bypass Remote Certificate Validation. Useful when testing with self-signed SSL certificates. 
         /// </summary>
-        private bool _bypassRemoteCertificateValidation;
+        private readonly bool _bypassRemoteCertificateValidation;
 
-        /// <summary> Constructor. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="uri"> URI of the resource. </param>
+        /// <summary>
+        /// Substrate client
+        /// </summary>
+        /// <param name="uri">Uri of the node</param>
+        /// <param name="chargeType">Charge type</param>
+        /// <param name="bypassRemoteCertificateValidation">By default, the client will validate the SSL certificate of the node. Set this to true to bypass this validation.</param>
         public SubstrateClient(Uri uri, ChargeType chargeType, bool bypassRemoteCertificateValidation = false)
         {
             _uri = uri;
@@ -254,6 +257,7 @@ public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, Cancell
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="parameters"></param>
+        /// <param name="blockhash"></param>
         /// <param name="token"></param>
         /// <returns></returns>
         public virtual async Task<T> GetStorageAsync<T>(string parameters, string blockhash, CancellationToken token) where T : IType, new()
@@ -272,14 +276,13 @@ public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, Cancell
         }
 
         /// <summary>
-        /// Subscribe Storage Key Async
+        /// Subscribe to storage changes
         /// </summary>
-        /// <param name="moduleName"></param>
-        /// <param name="itemName"></param>
-        /// <param name="parameter"></param>
+        /// <param name="storageParams"></param>
         /// <param name="callback"></param>
         /// <param name="token"></param>
         /// <returns></returns>
+        /// <exception cref="ClientNotConnectedException"></exception>
         public virtual async Task<string> SubscribeStorageKeyAsync(string storageParams, Action<string, StorageChangeSet> callback, CancellationToken token)
         {
             if (_socket?.State != WebSocketState.Open)
@@ -293,11 +296,12 @@ public virtual async Task<string> SubscribeStorageKeyAsync(string storageParams,
             return subscriptionId;
         }
 
-        /// <summary> Gets method asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <typeparam name="T"> Generic type parameter. </typeparam>
-        /// <param name="method"> The method. </param>
-        /// <returns> The method async&lt; t&gt; </returns>
+        /// <summary>
+        /// Get method
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="method"></param>
+        /// <returns></returns>
         public async Task<T> GetMethodAsync<T>(string method)
         {
             return await GetMethodAsync<T>(method, CancellationToken.None);
@@ -327,11 +331,11 @@ public async Task<T> GetMethodAsync<T>(string method, string parameter, Cancella
         }
 
         /// <summary>
-        /// Get an unchecked extrinsic.
+        /// Get extrinsic parameters
         /// </summary>
-        /// <param name="callArguments"></param>
+        /// <param name="method"></param>
         /// <param name="account"></param>
-        /// <param name="tip"></param>
+        /// <param name="charge"></param>
         /// <param name="lifeTime"></param>
         /// <param name="signed"></param>
         /// <param name="token"></param>
@@ -452,28 +456,16 @@ protected virtual void Dispose(bool disposing)
                     Logger.Debug("Client disposed.");
                 }
 
-                // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
-                // TODO: set large fields to null.
-
                 _disposedValue = true;
             }
         }
 
-        // TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
-        // ~SubstrateClient()
-        // {
-        //   // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
-        //   Dispose(false);
-        // }
-
         /// <summary> This code added to correctly implement the disposable pattern. </summary>
         /// <remarks> 19.09.2020. </remarks>
         public void Dispose()
         {
             // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
             Dispose(true);
-            // TODO: uncomment the following line if the finalizer is overridden above.
-            // GC.SuppressFinalize(this);
         }
 
         #endregion IDisposable Support
diff --git a/Substrate.NetApi/TypeConverters/ExtrinsicStatusJsonConverter.cs b/Substrate.NetApi/TypeConverters/ExtrinsicStatusJsonConverter.cs
index f1ab8f7..501aea4 100644
--- a/Substrate.NetApi/TypeConverters/ExtrinsicStatusJsonConverter.cs
+++ b/Substrate.NetApi/TypeConverters/ExtrinsicStatusJsonConverter.cs
@@ -8,6 +8,9 @@
 
 namespace Substrate.NetApi.TypeConverters
 {
+    /// <summary>
+    /// TransactionEventInfo JsonConverter
+    /// </summary>
     public class TransactionEventJsonConverter : JsonConverter<TransactionEventInfo>
     {
         /// <summary>Reads the JSON representation of the object.</summary>
@@ -95,6 +98,9 @@ public override void WriteJson(JsonWriter writer, TransactionEventInfo value, Js
         }
     }
 
+    /// <summary>
+    /// ExtrinsicStatus JsonConverter
+    /// </summary>
     public class ExtrinsicStatusJsonConverter : JsonConverter<ExtrinsicStatus>
     {
         /// <summary>Reads the JSON representation of the object.</summary>
diff --git a/Substrate.NetApi/Utils.cs b/Substrate.NetApi/Utils.cs
index ba2e603..bca0f61 100644
--- a/Substrate.NetApi/Utils.cs
+++ b/Substrate.NetApi/Utils.cs
@@ -14,8 +14,19 @@ public class Utils
         /// </summary>
         public enum HexStringFormat
         {
+            /// <summary>
+            /// Pure hex string without any separators.
+            /// </summary>
             Pure,
+
+            /// <summary>
+            /// Hex string with dash separators.
+            /// </summary>
             Dash,
+
+            /// <summary>
+            /// Hex string with 0x prefix.
+            /// </summary>
             Prefixed
         }
 
@@ -40,7 +51,7 @@ public static string Bytes2HexString(byte[] bytes, HexStringFormat format = HexS
                     return $"0x{BitConverter.ToString(bytes).Replace("-", string.Empty)}";
 
                 default:
-                    throw new Exception($"Unimplemented hex string format '{format}'");
+                    throw new NotSupportedException($"Unimplemented hex string format '{format}'");
             }
         }
 
@@ -64,7 +75,7 @@ public static byte[] StringValueArrayBytesArray(string valueArray)
                 if (byte.TryParse(strArray[i], out var parsedByte))
                     result[i] = parsedByte;
                 else
-                    throw new Exception(
+                    throw new NotSupportedException(
                         "Not valid string array for byte array conversion. Format should be [ 0-255, 0-255, ...]");
 
             return result;
@@ -82,7 +93,7 @@ public static byte[] HexToByteArray(string hex, bool evenLeftZeroPad = false)
             if (hex.Equals("0x0")) return new byte[] { 0x00 };
 
             if (hex.Length % 2 == 1 && !evenLeftZeroPad)
-                throw new Exception("The binary key cannot have an odd number of digits");
+                throw new NotSupportedException("The binary key cannot have an odd number of digits");
 
             if (hex.StartsWith("0x")) hex = hex.Substring(2);
 
@@ -119,7 +130,7 @@ public static object Bytes2Value(byte[] value, bool littleEndian = true)
                     return BitConverter.ToUInt64(value, 0);
 
                 default:
-                    throw new Exception($"Unhandled byte size {value.Length} for this method!");
+                    throw new NotSupportedException($"Unhandled byte size {value.Length} for this method!");
             }
         }
 
@@ -160,7 +171,7 @@ public static byte[] Value2Bytes(object value, bool littleEndian = true)
                     break;
 
                 default:
-                    throw new Exception("Unhandled byte size for this method!");
+                    throw new NotSupportedException("Unhandled byte size for this method!");
             }
 
             if (!littleEndian) Array.Reverse(result);
@@ -175,11 +186,6 @@ public static byte[] Value2Bytes(object value, bool littleEndian = true)
         public static int GetHexVal(char hex)
         {
             int val = hex;
-            //For uppercase A-F letters:
-            //return val - (val < 58 ? 48 : 55);
-            //For lowercase a-f letters:
-            //return val - (val < 58 ? 48 : 87);
-            //Or the two combined, but a bit slower:
             return val - (val < 58 ? 48 : val < 97 ? 55 : 87);
         }
 
@@ -205,8 +211,7 @@ public static byte[] GetPublicKeyFrom(string address)
         public static byte[] GetPublicKeyFrom(string address, out short network)
         {
             network = 42;
-            var PUBLIC_KEY_LENGTH = 32;
-            var PREFIX_SIZE = 0;
+            var publicKeyLength = 32;
             var pubkByteList = new List<byte>();
 
             var bs58decoded = Base58Local.Decode(address);
@@ -214,24 +219,24 @@ public static byte[] GetPublicKeyFrom(string address, out short network)
 
             byte[] ssPrefixed = { 0x53, 0x53, 0x35, 0x38, 0x50, 0x52, 0x45 };
 
+            int prefixSize;
             // 00000000b..=00111111b (0..=63 inclusive): Simple account/address/network identifier.
             if (len == 35)
             {
-                PREFIX_SIZE = 1;
+                prefixSize = 1;
                 // set network
                 network = bs58decoded[0];
             }
-            else
             // 01000000b..=01111111b (64..=127 inclusive)
-            if (len == 36)
+            else if (len == 36)
             {
-                PREFIX_SIZE = 2;
+                prefixSize = 2;
                 // set network
                 byte b2up = (byte)((bs58decoded[0] << 2) & 0b1111_1100);
                 byte b2lo = (byte)((bs58decoded[1] >> 6) & 0b0000_0011);
                 byte b2 = (byte)(b2up | b2lo);
                 byte b1 = (byte)(bs58decoded[1] & 0b0011_1111);
-                network = (short)BitConverter.ToInt16(
+                network = BitConverter.ToInt16(
                     new byte[] { b2, b1 }, 0); // big endian, for BitConverter
             }
             else
@@ -240,16 +245,16 @@ public static byte[] GetPublicKeyFrom(string address, out short network)
             }
 
             pubkByteList.AddRange(ssPrefixed);
-            pubkByteList.AddRange(bs58decoded.Take(PUBLIC_KEY_LENGTH + PREFIX_SIZE));
+            pubkByteList.AddRange(bs58decoded.Take(publicKeyLength + prefixSize));
 
             var blake2bHashed = HashExtension.Blake2(pubkByteList.ToArray(), 512);
-            if (bs58decoded[PUBLIC_KEY_LENGTH + PREFIX_SIZE] != blake2bHashed[0] ||
-                bs58decoded[PUBLIC_KEY_LENGTH + PREFIX_SIZE + 1] != blake2bHashed[1])
+            if (bs58decoded[publicKeyLength + prefixSize] != blake2bHashed[0] ||
+                bs58decoded[publicKeyLength + prefixSize + 1] != blake2bHashed[1])
             {
                 throw new NotSupportedException("Address checksum is wrong.");
             }
 
-            return bs58decoded.Skip(PREFIX_SIZE).Take(PUBLIC_KEY_LENGTH).ToArray();
+            return bs58decoded.Skip(prefixSize).Take(publicKeyLength).ToArray();
         }
 
         /// <summary>
@@ -265,7 +270,7 @@ public static string GetAddressFrom(byte[] bytes, short ss58Prefix = 42)
             var PUBLIC_KEY_LENGTH = 32;
             var KEY_SIZE = 0;
 
-            byte[] plainAddr = new byte[0];
+            byte[] plainAddr;
             // 00000000b..=00111111b (0..=63 inclusive): Simple account/address/network identifier.
             // The byte can be interpreted directly as such an identifier.
             if (ss58Prefix < 64)
@@ -275,12 +280,11 @@ public static string GetAddressFrom(byte[] bytes, short ss58Prefix = 42)
                 plainAddr[0] = (byte)ss58Prefix;
                 bytes.CopyTo(plainAddr.AsMemory(1));
             }
-            else
             // 01000000b..=01111111b (64..=127 inclusive): Full address/address/network identifier.
             // The lower 6 bits of this byte should be treated as the upper 6 bits of a 14 bit identifier
             // value, with the lower 8 bits defined by the following byte. This works for all identifiers
             // up to 2**14 (16,383).
-            if (ss58Prefix < 16384)
+            else if (ss58Prefix < 16384)
             {
                 KEY_SIZE = 2;
                 plainAddr = new byte[36];