// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: bgs/low/pb/client/account_types.proto
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = Google.Protobuf;
using pbc = Google.Protobuf.Collections;
using pbr = Google.Protobuf.Reflection;

namespace Bgs.Protocol.Account.V1
{
    /// <summary>Holder for reflection information generated from bgs/low/pb/client/account_types.proto</summary>
    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public static partial class AccountTypesReflection
    {

        #region Descriptor
        /// <summary>File descriptor for bgs/low/pb/client/account_types.proto</summary>
        public static pbr::FileDescriptor Descriptor
        {
            get { return descriptor; }
        }
        private static pbr::FileDescriptor descriptor;

        static AccountTypesReflection()
        {
            byte[] descriptorData = System.Convert.FromBase64String(
                string.Concat(
                  "CiViZ3MvbG93L3BiL2NsaWVudC9hY2NvdW50X3R5cGVzLnByb3RvEhdiZ3Mu",
                  "cHJvdG9jb2wuYWNjb3VudC52MRokYmdzL2xvdy9wYi9jbGllbnQvZW50aXR5",
                  "X3R5cGVzLnByb3RvGiFiZ3MvbG93L3BiL2NsaWVudC9ycGNfdHlwZXMucHJv",
                  "dG8iFwoJQWNjb3VudElkEgoKAmlkGAEgASgHIi0KDkFjY291bnRMaWNlbnNl",
                  "EgoKAmlkGAEgASgNEg8KB2V4cGlyZXMYAiABKAQiLQoRQWNjb3VudENyZWRl",
                  "bnRpYWwSCgoCaWQYASABKA0SDAoEZGF0YRgCIAEoDCKfBQoLQWNjb3VudEJs",
                  "b2ISCgoCaWQYAiABKAcSDgoGcmVnaW9uGAMgASgNEg0KBWVtYWlsGAQgAygJ",
                  "Eg0KBWZsYWdzGAUgASgEEhYKDnNlY3VyZV9yZWxlYXNlGAYgASgEEhcKD3do",
                  "aXRlbGlzdF9zdGFydBgHIAEoBBIVCg13aGl0ZWxpc3RfZW5kGAggASgEEhEK",
                  "CWZ1bGxfbmFtZRgKIAEoCRI5CghsaWNlbnNlcxgUIAMoCzInLmJncy5wcm90",
                  "b2NvbC5hY2NvdW50LnYxLkFjY291bnRMaWNlbnNlEj8KC2NyZWRlbnRpYWxz",
                  "GBUgAygLMiouYmdzLnByb3RvY29sLmFjY291bnQudjEuQWNjb3VudENyZWRl",
                  "bnRpYWwSPwoNYWNjb3VudF9saW5rcxgWIAMoCzIoLmJncy5wcm90b2NvbC5h",
                  "Y2NvdW50LnYxLkdhbWVBY2NvdW50TGluaxISCgpiYXR0bGVfdGFnGBcgASgJ",
                  "EhgKEGRlZmF1bHRfY3VycmVuY3kYGSABKAcSFAoMbGVnYWxfcmVnaW9uGBog",
                  "ASgNEhQKDGxlZ2FsX2xvY2FsZRgbIAEoBxIYChBjYWNoZV9leHBpcmF0aW9u",
                  "GB4gASgEEksKFXBhcmVudGFsX2NvbnRyb2xfaW5mbxgfIAEoCzIsLmJncy5w",
                  "cm90b2NvbC5hY2NvdW50LnYxLlBhcmVudGFsQ29udHJvbEluZm8SDwoHY291",
                  "bnRyeRggIAEoCRIYChBwcmVmZXJyZWRfcmVnaW9uGCEgASgNElIKFWlkZW50",
                  "aXR5X2NoZWNrX3N0YXR1cxgiIAEoDjIzLmJncy5wcm90b2NvbC5hY2NvdW50",
                  "LnYxLklkZW50aXR5VmVyaWZpY2F0aW9uU3RhdHVzIkUKD0FjY291bnRCbG9i",
                  "TGlzdBIyCgRibG9iGAEgAygLMiQuYmdzLnByb3RvY29sLmFjY291bnQudjEu",
                  "QWNjb3VudEJsb2IiQAoRR2FtZUFjY291bnRIYW5kbGUSCgoCaWQYASABKAcS",
                  "DwoHcHJvZ3JhbRgCIAEoBxIOCgZyZWdpb24YAyABKA0iYQoPR2FtZUFjY291",
                  "bnRMaW5rEkAKDGdhbWVfYWNjb3VudBgBIAEoCzIqLmJncy5wcm90b2NvbC5h",
                  "Y2NvdW50LnYxLkdhbWVBY2NvdW50SGFuZGxlEgwKBG5hbWUYAiABKAkizAMK",
                  "D0dhbWVBY2NvdW50QmxvYhJACgxnYW1lX2FjY291bnQYASABKAsyKi5iZ3Mu",
                  "cHJvdG9jb2wuYWNjb3VudC52MS5HYW1lQWNjb3VudEhhbmRsZRIMCgRuYW1l",
                  "GAIgASgJEhkKEXJlYWxtX3Blcm1pc3Npb25zGAMgASgNEg4KBnN0YXR1cxgE",
                  "IAEoDRINCgVmbGFncxgFIAEoBBIVCg1iaWxsaW5nX2ZsYWdzGAYgASgNEhgK",
                  "EGNhY2hlX2V4cGlyYXRpb24YByABKAQSHwoXc3Vic2NyaXB0aW9uX2V4cGly",
                  "YXRpb24YCiABKAQSFwoPdW5pdHNfcmVtYWluaW5nGAsgASgNEhkKEXN0YXR1",
                  "c19leHBpcmF0aW9uGAwgASgEEhEKCWJveF9sZXZlbBgNIAEoDRIcChRib3hf",
                  "bGV2ZWxfZXhwaXJhdGlvbhgOIAEoBBI5CghsaWNlbnNlcxgUIAMoCzInLmJn",
                  "cy5wcm90b2NvbC5hY2NvdW50LnYxLkFjY291bnRMaWNlbnNlEhMKC3JhZl9h",
                  "Y2NvdW50GBUgASgHEhAKCHJhZl9pbmZvGBYgASgMEhYKDnJhZl9leHBpcmF0",
                  "aW9uGBcgASgEIk0KE0dhbWVBY2NvdW50QmxvYkxpc3QSNgoEYmxvYhgBIAMo",
                  "CzIoLmJncy5wcm90b2NvbC5hY2NvdW50LnYxLkdhbWVBY2NvdW50QmxvYiKN",
                  "AQoQQWNjb3VudFJlZmVyZW5jZRIKCgJpZBgBIAEoBxINCgVlbWFpbBgCIAEo",
                  "CRI6CgZoYW5kbGUYAyABKAsyKi5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5H",
                  "YW1lQWNjb3VudEhhbmRsZRISCgpiYXR0bGVfdGFnGAQgASgJEg4KBnJlZ2lv",
                  "bhgKIAEoDSKrAQoISWRlbnRpdHkSMwoHYWNjb3VudBgBIAEoCzIiLmJncy5w",
                  "cm90b2NvbC5hY2NvdW50LnYxLkFjY291bnRJZBJACgxnYW1lX2FjY291bnQY",
                  "AiABKAsyKi5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5HYW1lQWNjb3VudEhh",
                  "bmRsZRIoCgdwcm9jZXNzGAMgASgLMhcuYmdzLnByb3RvY29sLlByb2Nlc3NJ",
                  "ZCIqCgpQcm9ncmFtVGFnEg8KB3Byb2dyYW0YASABKAcSCwoDdGFnGAIgASgH",
                  "IigKCVJlZ2lvblRhZxIOCgZyZWdpb24YASABKAcSCwoDdGFnGAIgASgHIrAC",
                  "ChBBY2NvdW50RmllbGRUYWdzEh4KFmFjY291bnRfbGV2ZWxfaW5mb190YWcY",
                  "AiABKAcSGAoQcHJpdmFjeV9pbmZvX3RhZxgDIAEoBxIhChlwYXJlbnRhbF9j",
                  "b250cm9sX2luZm9fdGFnGAQgASgHEkEKFGdhbWVfbGV2ZWxfaW5mb190YWdz",
                  "GAcgAygLMiMuYmdzLnByb3RvY29sLmFjY291bnQudjEuUHJvZ3JhbVRhZxI9",
                  "ChBnYW1lX3N0YXR1c190YWdzGAkgAygLMiMuYmdzLnByb3RvY29sLmFjY291",
                  "bnQudjEuUHJvZ3JhbVRhZxI9ChFnYW1lX2FjY291bnRfdGFncxgLIAMoCzIi",
                  "LmJncy5wcm90b2NvbC5hY2NvdW50LnYxLlJlZ2lvblRhZyJ+ChRHYW1lQWNj",
                  "b3VudEZpZWxkVGFncxIbChNnYW1lX2xldmVsX2luZm9fdGFnGAIgASgHEhoK",
                  "EmdhbWVfdGltZV9pbmZvX3RhZxgDIAEoBxIXCg9nYW1lX3N0YXR1c190YWcY",
                  "BCABKAcSFAoMcmFmX2luZm9fdGFnGAUgASgHIuMBChNBY2NvdW50RmllbGRP",
                  "cHRpb25zEhIKCmFsbF9maWVsZHMYASABKAgSIAoYZmllbGRfYWNjb3VudF9s",
                  "ZXZlbF9pbmZvGAIgASgIEhoKEmZpZWxkX3ByaXZhY3lfaW5mbxgDIAEoCBIj",
                  "ChtmaWVsZF9wYXJlbnRhbF9jb250cm9sX2luZm8YBCABKAgSHQoVZmllbGRf",
                  "Z2FtZV9sZXZlbF9pbmZvGAYgASgIEhkKEWZpZWxkX2dhbWVfc3RhdHVzGAcg",
                  "ASgIEhsKE2ZpZWxkX2dhbWVfYWNjb3VudHMYCCABKAginQEKF0dhbWVBY2Nv",
                  "dW50RmllbGRPcHRpb25zEhIKCmFsbF9maWVsZHMYASABKAgSHQoVZmllbGRf",
                  "Z2FtZV9sZXZlbF9pbmZvGAIgASgIEhwKFGZpZWxkX2dhbWVfdGltZV9pbmZv",
                  "GAMgASgIEhkKEWZpZWxkX2dhbWVfc3RhdHVzGAQgASgIEhYKDmZpZWxkX3Jh",
                  "Zl9pbmZvGAUgASgIIowDChNTdWJzY3JpYmVyUmVmZXJlbmNlEhEKCW9iamVj",
                  "dF9pZBgBIAEoBBIpCgllbnRpdHlfaWQYAiABKAsyFi5iZ3MucHJvdG9jb2wu",
                  "RW50aXR5SWQSRQoPYWNjb3VudF9vcHRpb25zGAMgASgLMiwuYmdzLnByb3Rv",
                  "Y29sLmFjY291bnQudjEuQWNjb3VudEZpZWxkT3B0aW9ucxI/CgxhY2NvdW50",
                  "X3RhZ3MYBCABKAsyKS5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5BY2NvdW50",
                  "RmllbGRUYWdzEk4KFGdhbWVfYWNjb3VudF9vcHRpb25zGAUgASgLMjAuYmdz",
                  "LnByb3RvY29sLmFjY291bnQudjEuR2FtZUFjY291bnRGaWVsZE9wdGlvbnMS",
                  "SAoRZ2FtZV9hY2NvdW50X3RhZ3MYBiABKAsyLS5iZ3MucHJvdG9jb2wuYWNj",
                  "b3VudC52MS5HYW1lQWNjb3VudEZpZWxkVGFncxIVCg1zdWJzY3JpYmVyX2lk",
                  "GAcgASgEItwCChBBY2NvdW50TGV2ZWxJbmZvEjkKCGxpY2Vuc2VzGAMgAygL",
                  "MicuYmdzLnByb3RvY29sLmFjY291bnQudjEuQWNjb3VudExpY2Vuc2USGAoQ",
                  "ZGVmYXVsdF9jdXJyZW5jeRgEIAEoBxIPCgdjb3VudHJ5GAUgASgJEhgKEHBy",
                  "ZWZlcnJlZF9yZWdpb24YBiABKA0SEQoJZnVsbF9uYW1lGAcgASgJEhIKCmJh",
                  "dHRsZV90YWcYCCABKAkSDQoFbXV0ZWQYCSABKAgSFQoNbWFudWFsX3Jldmll",
                  "dxgKIAEoCBIYChBhY2NvdW50X3BhaWRfYW55GAsgASgIElIKFWlkZW50aXR5",
                  "X2NoZWNrX3N0YXR1cxgMIAEoDjIzLmJncy5wcm90b2NvbC5hY2NvdW50LnYx",
                  "LklkZW50aXR5VmVyaWZpY2F0aW9uU3RhdHVzEg0KBWVtYWlsGA0gASgJIpUC",
                  "CgtQcml2YWN5SW5mbxIUCgxpc191c2luZ19yaWQYAyABKAgSKwojaXNfcmVh",
                  "bF9pZF92aXNpYmxlX2Zvcl92aWV3X2ZyaWVuZHMYBCABKAgSJAocaXNfaGlk",
                  "ZGVuX2Zyb21fZnJpZW5kX2ZpbmRlchgFIAEoCBJPChFnYW1lX2luZm9fcHJp",
                  "dmFjeRgGIAEoDjI0LmJncy5wcm90b2NvbC5hY2NvdW50LnYxLlByaXZhY3lJ",
                  "bmZvLkdhbWVJbmZvUHJpdmFjeSJMCg9HYW1lSW5mb1ByaXZhY3kSDgoKUFJJ",
                  "VkFDWV9NRRAAEhMKD1BSSVZBQ1lfRlJJRU5EUxABEhQKEFBSSVZBQ1lfRVZF",
                  "UllPTkUQAiKkAQoTUGFyZW50YWxDb250cm9sSW5mbxIQCgh0aW1lem9uZRgD",
                  "IAEoCRIXCg9taW51dGVzX3Blcl9kYXkYBCABKA0SGAoQbWludXRlc19wZXJf",
                  "d2VlaxgFIAEoDRIZChFjYW5fcmVjZWl2ZV92b2ljZRgGIAEoCBIWCg5jYW5f",
                  "c2VuZF92b2ljZRgHIAEoCBIVCg1wbGF5X3NjaGVkdWxlGAggAygIItMBCg1H",
                  "YW1lTGV2ZWxJbmZvEhAKCGlzX3RyaWFsGAQgASgIEhMKC2lzX2xpZmV0aW1l",
                  "GAUgASgIEhUKDWlzX3Jlc3RyaWN0ZWQYBiABKAgSDwoHaXNfYmV0YRgHIAEo",
                  "CBIMCgRuYW1lGAggASgJEg8KB3Byb2dyYW0YCSABKAcSOQoIbGljZW5zZXMY",
                  "CiADKAsyJy5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5BY2NvdW50TGljZW5z",
                  "ZRIZChFyZWFsbV9wZXJtaXNzaW9ucxgLIAEoDSKFAQoMR2FtZVRpbWVJbmZv",
                  "Eh4KFmlzX3VubGltaXRlZF9wbGF5X3RpbWUYAyABKAgSGQoRcGxheV90aW1l",
                  "X2V4cGlyZXMYBSABKAQSFwoPaXNfc3Vic2NyaXB0aW9uGAYgASgIEiEKGWlz",
                  "X3JlY3VycmluZ19zdWJzY3JpcHRpb24YByABKAgirQEKFUdhbWVUaW1lUmVt",
                  "YWluaW5nSW5mbxIZChFtaW51dGVzX3JlbWFpbmluZxgBIAEoDRIoCiBwYXJl",
                  "bnRhbF9kYWlseV9taW51dGVzX3JlbWFpbmluZxgCIAEoDRIpCiFwYXJlbnRh",
                  "bF93ZWVrbHlfbWludXRlc19yZW1haW5pbmcYAyABKA0SJAocc2Vjb25kc19y",
                  "ZW1haW5pbmdfdW50aWxfa2ljaxgEIAEoDSKQAQoKR2FtZVN0YXR1cxIUCgxp",
                  "c19zdXNwZW5kZWQYBCABKAgSEQoJaXNfYmFubmVkGAUgASgIEhoKEnN1c3Bl",
                  "bnNpb25fZXhwaXJlcxgGIAEoBBIPCgdwcm9ncmFtGAcgASgHEhEKCWlzX2xv",
                  "Y2tlZBgIIAEoCBIZChFpc19iYW1fdW5sb2NrYWJsZRgJIAEoCCIbCgdSQUZJ",
                  "bmZvEhAKCHJhZl9pbmZvGAEgASgMItEBCg9HYW1lU2Vzc2lvbkluZm8SFgoK",
                  "c3RhcnRfdGltZRgDIAEoDUICGAESPgoIbG9jYXRpb24YBCABKAsyLC5iZ3Mu",
                  "cHJvdG9jb2wuYWNjb3VudC52MS5HYW1lU2Vzc2lvbkxvY2F0aW9uEhYKDmhh",
                  "c19iZW5lZmFjdG9yGAUgASgIEhQKDGlzX3VzaW5nX2lnchgGIAEoCBIgChhw",
                  "YXJlbnRhbF9jb250cm9sc19hY3RpdmUYByABKAgSFgoOc3RhcnRfdGltZV9z",
                  "ZWMYCCABKAQiRAoVR2FtZVNlc3Npb25VcGRhdGVJbmZvEisKBGNhaXMYCCAB",
                  "KAsyHS5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5DQUlTIkgKE0dhbWVTZXNz",
                  "aW9uTG9jYXRpb24SEgoKaXBfYWRkcmVzcxgBIAEoCRIPCgdjb3VudHJ5GAIg",
                  "ASgNEgwKBGNpdHkYAyABKAkiTwoEQ0FJUxIWCg5wbGF5ZWRfbWludXRlcxgB",
                  "IAEoDRIWCg5yZXN0ZWRfbWludXRlcxgCIAEoDRIXCg9sYXN0X2hlYXJkX3Rp",
                  "bWUYAyABKAQiXQoPR2FtZUFjY291bnRMaXN0Eg4KBnJlZ2lvbhgDIAEoDRI6",
                  "CgZoYW5kbGUYBCADKAsyKi5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5HYW1l",
                  "QWNjb3VudEhhbmRsZSKaAwoMQWNjb3VudFN0YXRlEkUKEmFjY291bnRfbGV2",
                  "ZWxfaW5mbxgBIAEoCzIpLmJncy5wcm90b2NvbC5hY2NvdW50LnYxLkFjY291",
                  "bnRMZXZlbEluZm8SOgoMcHJpdmFjeV9pbmZvGAIgASgLMiQuYmdzLnByb3Rv",
                  "Y29sLmFjY291bnQudjEuUHJpdmFjeUluZm8SSwoVcGFyZW50YWxfY29udHJv",
                  "bF9pbmZvGAMgASgLMiwuYmdzLnByb3RvY29sLmFjY291bnQudjEuUGFyZW50",
                  "YWxDb250cm9sSW5mbxI/Cg9nYW1lX2xldmVsX2luZm8YBSADKAsyJi5iZ3Mu",
                  "cHJvdG9jb2wuYWNjb3VudC52MS5HYW1lTGV2ZWxJbmZvEjgKC2dhbWVfc3Rh",
                  "dHVzGAYgAygLMiMuYmdzLnByb3RvY29sLmFjY291bnQudjEuR2FtZVN0YXR1",
                  "cxI/Cg1nYW1lX2FjY291bnRzGAcgAygLMiguYmdzLnByb3RvY29sLmFjY291",
                  "bnQudjEuR2FtZUFjY291bnRMaXN0IpMBChJBY2NvdW50U3RhdGVUYWdnZWQS",
                  "PAoNYWNjb3VudF9zdGF0ZRgBIAEoCzIlLmJncy5wcm90b2NvbC5hY2NvdW50",
                  "LnYxLkFjY291bnRTdGF0ZRI/CgxhY2NvdW50X3RhZ3MYAiABKAsyKS5iZ3Mu",
                  "cHJvdG9jb2wuYWNjb3VudC52MS5BY2NvdW50RmllbGRUYWdzIoACChBHYW1l",
                  "QWNjb3VudFN0YXRlEj8KD2dhbWVfbGV2ZWxfaW5mbxgBIAEoCzImLmJncy5w",
                  "cm90b2NvbC5hY2NvdW50LnYxLkdhbWVMZXZlbEluZm8SPQoOZ2FtZV90aW1l",
                  "X2luZm8YAiABKAsyJS5iZ3MucHJvdG9jb2wuYWNjb3VudC52MS5HYW1lVGlt",
                  "ZUluZm8SOAoLZ2FtZV9zdGF0dXMYAyABKAsyIy5iZ3MucHJvdG9jb2wuYWNj",
                  "b3VudC52MS5HYW1lU3RhdHVzEjIKCHJhZl9pbmZvGAQgASgLMiAuYmdzLnBy",
                  "b3RvY29sLmFjY291bnQudjEuUkFGSW5mbyKpAQoWR2FtZUFjY291bnRTdGF0",
                  "ZVRhZ2dlZBJFChJnYW1lX2FjY291bnRfc3RhdGUYASABKAsyKS5iZ3MucHJv",
                  "dG9jb2wuYWNjb3VudC52MS5HYW1lQWNjb3VudFN0YXRlEkgKEWdhbWVfYWNj",
                  "b3VudF90YWdzGAIgASgLMi0uYmdzLnByb3RvY29sLmFjY291bnQudjEuR2Ft",
                  "ZUFjY291bnRGaWVsZFRhZ3MiLwoOQXV0aG9yaXplZERhdGESDAoEZGF0YRgB",
                  "IAEoCRIPCgdsaWNlbnNlGAIgAygNKo4BChpJZGVudGl0eVZlcmlmaWNhdGlv",
                  "blN0YXR1cxIRCg1JREVOVF9OT19EQVRBEAASEQoNSURFTlRfUEVORElORxAB",
                  "EhAKDElERU5UX0ZBSUxFRBAEEhEKDUlERU5UX1NVQ0NFU1MQBRISCg5JREVO",
                  "VF9TVUNDX01OTBAGEhEKDUlERU5UX1VOS05PV04QB0ICSAJiBnByb3RvMw=="));
            descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
                new pbr::FileDescriptor[] { Bgs.Protocol.EntityTypesReflection.Descriptor, Bgs.Protocol.RpcTypesReflection.Descriptor, },
                new pbr::GeneratedClrTypeInfo(new[] { typeof(Bgs.Protocol.Account.V1.IdentityVerificationStatus), }, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountId), Bgs.Protocol.Account.V1.AccountId.Parser, new[]{ "Id" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountLicense), Bgs.Protocol.Account.V1.AccountLicense.Parser, new[]{ "Id", "Expires" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountCredential), Bgs.Protocol.Account.V1.AccountCredential.Parser, new[]{ "Id", "Data" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountBlob), Bgs.Protocol.Account.V1.AccountBlob.Parser, new[]{ "Id", "Region", "Email", "Flags", "SecureRelease", "WhitelistStart", "WhitelistEnd", "FullName", "Licenses", "Credentials", "AccountLinks", "BattleTag", "DefaultCurrency", "LegalRegion", "LegalLocale", "CacheExpiration", "ParentalControlInfo", "Country", "PreferredRegion", "IdentityCheckStatus" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountBlobList), Bgs.Protocol.Account.V1.AccountBlobList.Parser, new[]{ "Blob" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountHandle), Bgs.Protocol.Account.V1.GameAccountHandle.Parser, new[]{ "Id", "Program", "Region" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountLink), Bgs.Protocol.Account.V1.GameAccountLink.Parser, new[]{ "GameAccount", "Name" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountBlob), Bgs.Protocol.Account.V1.GameAccountBlob.Parser, new[]{ "GameAccount", "Name", "RealmPermissions", "Status", "Flags", "BillingFlags", "CacheExpiration", "SubscriptionExpiration", "UnitsRemaining", "StatusExpiration", "BoxLevel", "BoxLevelExpiration", "Licenses", "RafAccount", "RafInfo", "RafExpiration" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountBlobList), Bgs.Protocol.Account.V1.GameAccountBlobList.Parser, new[]{ "Blob" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountReference), Bgs.Protocol.Account.V1.AccountReference.Parser, new[]{ "Id", "Email", "Handle", "BattleTag", "Region" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.Identity), Bgs.Protocol.Account.V1.Identity.Parser, new[]{ "Account", "GameAccount", "Process" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.ProgramTag), Bgs.Protocol.Account.V1.ProgramTag.Parser, new[]{ "Program", "Tag" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.RegionTag), Bgs.Protocol.Account.V1.RegionTag.Parser, new[]{ "Region", "Tag" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountFieldTags), Bgs.Protocol.Account.V1.AccountFieldTags.Parser, new[]{ "AccountLevelInfoTag", "PrivacyInfoTag", "ParentalControlInfoTag", "GameLevelInfoTags", "GameStatusTags", "GameAccountTags" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountFieldTags), Bgs.Protocol.Account.V1.GameAccountFieldTags.Parser, new[]{ "GameLevelInfoTag", "GameTimeInfoTag", "GameStatusTag", "RafInfoTag" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountFieldOptions), Bgs.Protocol.Account.V1.AccountFieldOptions.Parser, new[]{ "AllFields", "FieldAccountLevelInfo", "FieldPrivacyInfo", "FieldParentalControlInfo", "FieldGameLevelInfo", "FieldGameStatus", "FieldGameAccounts" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountFieldOptions), Bgs.Protocol.Account.V1.GameAccountFieldOptions.Parser, new[]{ "AllFields", "FieldGameLevelInfo", "FieldGameTimeInfo", "FieldGameStatus", "FieldRafInfo" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.SubscriberReference), Bgs.Protocol.Account.V1.SubscriberReference.Parser, new[]{ "ObjectId", "EntityId", "AccountOptions", "AccountTags", "GameAccountOptions", "GameAccountTags", "SubscriberId" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountLevelInfo), Bgs.Protocol.Account.V1.AccountLevelInfo.Parser, new[]{ "Licenses", "DefaultCurrency", "Country", "PreferredRegion", "FullName", "BattleTag", "Muted", "ManualReview", "AccountPaidAny", "IdentityCheckStatus", "Email" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.PrivacyInfo), Bgs.Protocol.Account.V1.PrivacyInfo.Parser, new[]{ "IsUsingRid", "IsRealIdVisibleForViewFriends", "IsHiddenFromFriendFinder", "GameInfoPrivacy" }, null, new[]{ typeof(Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy) }, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.ParentalControlInfo), Bgs.Protocol.Account.V1.ParentalControlInfo.Parser, new[]{ "Timezone", "MinutesPerDay", "MinutesPerWeek", "CanReceiveVoice", "CanSendVoice", "PlaySchedule" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameLevelInfo), Bgs.Protocol.Account.V1.GameLevelInfo.Parser, new[]{ "IsTrial", "IsLifetime", "IsRestricted", "IsBeta", "Name", "Program", "Licenses", "RealmPermissions" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameTimeInfo), Bgs.Protocol.Account.V1.GameTimeInfo.Parser, new[]{ "IsUnlimitedPlayTime", "PlayTimeExpires", "IsSubscription", "IsRecurringSubscription" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameTimeRemainingInfo), Bgs.Protocol.Account.V1.GameTimeRemainingInfo.Parser, new[]{ "MinutesRemaining", "ParentalDailyMinutesRemaining", "ParentalWeeklyMinutesRemaining", "SecondsRemainingUntilKick" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameStatus), Bgs.Protocol.Account.V1.GameStatus.Parser, new[]{ "IsSuspended", "IsBanned", "SuspensionExpires", "Program", "IsLocked", "IsBamUnlockable" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.RAFInfo), Bgs.Protocol.Account.V1.RAFInfo.Parser, new[]{ "RafInfo" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameSessionInfo), Bgs.Protocol.Account.V1.GameSessionInfo.Parser, new[]{ "StartTime", "Location", "HasBenefactor", "IsUsingIgr", "ParentalControlsActive", "StartTimeSec" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameSessionUpdateInfo), Bgs.Protocol.Account.V1.GameSessionUpdateInfo.Parser, new[]{ "Cais" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameSessionLocation), Bgs.Protocol.Account.V1.GameSessionLocation.Parser, new[]{ "IpAddress", "Country", "City" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.CAIS), Bgs.Protocol.Account.V1.CAIS.Parser, new[]{ "PlayedMinutes", "RestedMinutes", "LastHeardTime" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountList), Bgs.Protocol.Account.V1.GameAccountList.Parser, new[]{ "Region", "Handle" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountState), Bgs.Protocol.Account.V1.AccountState.Parser, new[]{ "AccountLevelInfo", "PrivacyInfo", "ParentalControlInfo", "GameLevelInfo", "GameStatus", "GameAccounts" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AccountStateTagged), Bgs.Protocol.Account.V1.AccountStateTagged.Parser, new[]{ "AccountState", "AccountTags" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountState), Bgs.Protocol.Account.V1.GameAccountState.Parser, new[]{ "GameLevelInfo", "GameTimeInfo", "GameStatus", "RafInfo" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.GameAccountStateTagged), Bgs.Protocol.Account.V1.GameAccountStateTagged.Parser, new[]{ "GameAccountState", "GameAccountTags" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Account.V1.AuthorizedData), Bgs.Protocol.Account.V1.AuthorizedData.Parser, new[]{ "Data", "License" }, null, null, null)
                }));
        }
        #endregion

    }
    #region Enums
    public enum IdentityVerificationStatus
    {
        IDENT_NO_DATA = 0,
        IDENT_PENDING = 1,
        IDENT_FAILED = 4,
        IDENT_SUCCESS = 5,
        IDENT_SUCC_MNL = 6,
        IDENT_UNKNOWN = 7,
    }

    #endregion

    #region Messages
    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountId : pb::IMessage<AccountId>
    {
        private static readonly pb::MessageParser<AccountId> _parser = new pb::MessageParser<AccountId>(() => new AccountId());
        public static pb::MessageParser<AccountId> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[0]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountId()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountId(AccountId other) : this()
        {
            id_ = other.id_;
        }

        public AccountId Clone()
        {
            return new AccountId(this);
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 1;
        private uint id_;
        public uint Id
        {
            get { return id_; }
            set
            {
                id_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountId);
        }

        public bool Equals(AccountId other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Id != other.Id) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Id != 0) hash ^= Id.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Id != 0)
            {
                output.WriteRawTag(13);
                output.WriteFixed32(Id);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Id != 0)
            {
                size += 1 + 4;
            }
            return size;
        }

        public void MergeFrom(AccountId other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Id != 0)
            {
                Id = other.Id;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 13:
                        {
                            Id = input.ReadFixed32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountLicense : pb::IMessage<AccountLicense>
    {
        private static readonly pb::MessageParser<AccountLicense> _parser = new pb::MessageParser<AccountLicense>(() => new AccountLicense());
        public static pb::MessageParser<AccountLicense> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[1]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountLicense()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountLicense(AccountLicense other) : this()
        {
            id_ = other.id_;
            expires_ = other.expires_;
        }

        public AccountLicense Clone()
        {
            return new AccountLicense(this);
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 1;
        private uint id_;
        public uint Id
        {
            get { return id_; }
            set
            {
                id_ = value;
            }
        }

        /// <summary>Field number for the "expires" field.</summary>
        public const int ExpiresFieldNumber = 2;
        private ulong expires_;
        public ulong Expires
        {
            get { return expires_; }
            set
            {
                expires_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountLicense);
        }

        public bool Equals(AccountLicense other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Id != other.Id) return false;
            if (Expires != other.Expires) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Id != 0) hash ^= Id.GetHashCode();
            if (Expires != 0UL) hash ^= Expires.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Id != 0)
            {
                output.WriteRawTag(8);
                output.WriteUInt32(Id);
            }
            if (Expires != 0UL)
            {
                output.WriteRawTag(16);
                output.WriteUInt64(Expires);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Id != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
            }
            if (Expires != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Expires);
            }
            return size;
        }

        public void MergeFrom(AccountLicense other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Id != 0)
            {
                Id = other.Id;
            }
            if (other.Expires != 0UL)
            {
                Expires = other.Expires;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            Id = input.ReadUInt32();
                            break;
                        }
                    case 16:
                        {
                            Expires = input.ReadUInt64();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountCredential : pb::IMessage<AccountCredential>
    {
        private static readonly pb::MessageParser<AccountCredential> _parser = new pb::MessageParser<AccountCredential>(() => new AccountCredential());
        public static pb::MessageParser<AccountCredential> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[2]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountCredential()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountCredential(AccountCredential other) : this()
        {
            id_ = other.id_;
            data_ = other.data_;
        }

        public AccountCredential Clone()
        {
            return new AccountCredential(this);
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 1;
        private uint id_;
        public uint Id
        {
            get { return id_; }
            set
            {
                id_ = value;
            }
        }

        /// <summary>Field number for the "data" field.</summary>
        public const int DataFieldNumber = 2;
        private pb::ByteString data_ = pb::ByteString.Empty;
        public pb::ByteString Data
        {
            get { return data_; }
            set
            {
                data_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountCredential);
        }

        public bool Equals(AccountCredential other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Id != other.Id) return false;
            if (Data != other.Data) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Id != 0) hash ^= Id.GetHashCode();
            if (Data.Length != 0) hash ^= Data.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Id != 0)
            {
                output.WriteRawTag(8);
                output.WriteUInt32(Id);
            }
            if (Data.Length != 0)
            {
                output.WriteRawTag(18);
                output.WriteBytes(Data);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Id != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Id);
            }
            if (Data.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);
            }
            return size;
        }

        public void MergeFrom(AccountCredential other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Id != 0)
            {
                Id = other.Id;
            }
            if (other.Data.Length != 0)
            {
                Data = other.Data;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            Id = input.ReadUInt32();
                            break;
                        }
                    case 18:
                        {
                            Data = input.ReadBytes();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountBlob : pb::IMessage<AccountBlob>
    {
        private static readonly pb::MessageParser<AccountBlob> _parser = new pb::MessageParser<AccountBlob>(() => new AccountBlob());
        public static pb::MessageParser<AccountBlob> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[3]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountBlob()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountBlob(AccountBlob other) : this()
        {
            id_ = other.id_;
            region_ = other.region_;
            email_ = other.email_.Clone();
            flags_ = other.flags_;
            secureRelease_ = other.secureRelease_;
            whitelistStart_ = other.whitelistStart_;
            whitelistEnd_ = other.whitelistEnd_;
            fullName_ = other.fullName_;
            licenses_ = other.licenses_.Clone();
            credentials_ = other.credentials_.Clone();
            accountLinks_ = other.accountLinks_.Clone();
            battleTag_ = other.battleTag_;
            defaultCurrency_ = other.defaultCurrency_;
            legalRegion_ = other.legalRegion_;
            legalLocale_ = other.legalLocale_;
            cacheExpiration_ = other.cacheExpiration_;
            ParentalControlInfo = other.parentalControlInfo_ != null ? other.ParentalControlInfo.Clone() : null;
            country_ = other.country_;
            preferredRegion_ = other.preferredRegion_;
            identityCheckStatus_ = other.identityCheckStatus_;
        }

        public AccountBlob Clone()
        {
            return new AccountBlob(this);
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 2;
        private uint id_;
        public uint Id
        {
            get { return id_; }
            set
            {
                id_ = value;
            }
        }

        /// <summary>Field number for the "region" field.</summary>
        public const int RegionFieldNumber = 3;
        private uint region_;
        public uint Region
        {
            get { return region_; }
            set
            {
                region_ = value;
            }
        }

        /// <summary>Field number for the "email" field.</summary>
        public const int EmailFieldNumber = 4;
        private static readonly pb::FieldCodec<string> _repeated_email_codec
            = pb::FieldCodec.ForString(34);
        private readonly pbc::RepeatedField<string> email_ = new pbc::RepeatedField<string>();
        public pbc::RepeatedField<string> Email
        {
            get { return email_; }
        }

        /// <summary>Field number for the "flags" field.</summary>
        public const int FlagsFieldNumber = 5;
        private ulong flags_;
        public ulong Flags
        {
            get { return flags_; }
            set
            {
                flags_ = value;
            }
        }

        /// <summary>Field number for the "secure_release" field.</summary>
        public const int SecureReleaseFieldNumber = 6;
        private ulong secureRelease_;
        public ulong SecureRelease
        {
            get { return secureRelease_; }
            set
            {
                secureRelease_ = value;
            }
        }

        /// <summary>Field number for the "whitelist_start" field.</summary>
        public const int WhitelistStartFieldNumber = 7;
        private ulong whitelistStart_;
        public ulong WhitelistStart
        {
            get { return whitelistStart_; }
            set
            {
                whitelistStart_ = value;
            }
        }

        /// <summary>Field number for the "whitelist_end" field.</summary>
        public const int WhitelistEndFieldNumber = 8;
        private ulong whitelistEnd_;
        public ulong WhitelistEnd
        {
            get { return whitelistEnd_; }
            set
            {
                whitelistEnd_ = value;
            }
        }

        /// <summary>Field number for the "full_name" field.</summary>
        public const int FullNameFieldNumber = 10;
        private string fullName_ = "";
        public string FullName
        {
            get { return fullName_; }
            set
            {
                fullName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "licenses" field.</summary>
        public const int LicensesFieldNumber = 20;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.AccountLicense> _repeated_licenses_codec
            = pb::FieldCodec.ForMessage(162, Bgs.Protocol.Account.V1.AccountLicense.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> licenses_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> Licenses
        {
            get { return licenses_; }
        }

        /// <summary>Field number for the "credentials" field.</summary>
        public const int CredentialsFieldNumber = 21;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.AccountCredential> _repeated_credentials_codec
            = pb::FieldCodec.ForMessage(170, Bgs.Protocol.Account.V1.AccountCredential.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountCredential> credentials_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountCredential>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountCredential> Credentials
        {
            get { return credentials_; }
        }

        /// <summary>Field number for the "account_links" field.</summary>
        public const int AccountLinksFieldNumber = 22;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.GameAccountLink> _repeated_accountLinks_codec
            = pb::FieldCodec.ForMessage(178, Bgs.Protocol.Account.V1.GameAccountLink.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountLink> accountLinks_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountLink>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountLink> AccountLinks
        {
            get { return accountLinks_; }
        }

        /// <summary>Field number for the "battle_tag" field.</summary>
        public const int BattleTagFieldNumber = 23;
        private string battleTag_ = "";
        public string BattleTag
        {
            get { return battleTag_; }
            set
            {
                battleTag_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "default_currency" field.</summary>
        public const int DefaultCurrencyFieldNumber = 25;
        private uint defaultCurrency_;
        public uint DefaultCurrency
        {
            get { return defaultCurrency_; }
            set
            {
                defaultCurrency_ = value;
            }
        }

        /// <summary>Field number for the "legal_region" field.</summary>
        public const int LegalRegionFieldNumber = 26;
        private uint legalRegion_;
        public uint LegalRegion
        {
            get { return legalRegion_; }
            set
            {
                legalRegion_ = value;
            }
        }

        /// <summary>Field number for the "legal_locale" field.</summary>
        public const int LegalLocaleFieldNumber = 27;
        private uint legalLocale_;
        public uint LegalLocale
        {
            get { return legalLocale_; }
            set
            {
                legalLocale_ = value;
            }
        }

        /// <summary>Field number for the "cache_expiration" field.</summary>
        public const int CacheExpirationFieldNumber = 30;
        private ulong cacheExpiration_;
        public ulong CacheExpiration
        {
            get { return cacheExpiration_; }
            set
            {
                cacheExpiration_ = value;
            }
        }

        /// <summary>Field number for the "parental_control_info" field.</summary>
        public const int ParentalControlInfoFieldNumber = 31;
        private Bgs.Protocol.Account.V1.ParentalControlInfo parentalControlInfo_;
        public Bgs.Protocol.Account.V1.ParentalControlInfo ParentalControlInfo
        {
            get { return parentalControlInfo_; }
            set
            {
                parentalControlInfo_ = value;
            }
        }

        /// <summary>Field number for the "country" field.</summary>
        public const int CountryFieldNumber = 32;
        private string country_ = "";
        public string Country
        {
            get { return country_; }
            set
            {
                country_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "preferred_region" field.</summary>
        public const int PreferredRegionFieldNumber = 33;
        private uint preferredRegion_;
        public uint PreferredRegion
        {
            get { return preferredRegion_; }
            set
            {
                preferredRegion_ = value;
            }
        }

        /// <summary>Field number for the "identity_check_status" field.</summary>
        public const int IdentityCheckStatusFieldNumber = 34;
        private Bgs.Protocol.Account.V1.IdentityVerificationStatus identityCheckStatus_ = Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA;
        public Bgs.Protocol.Account.V1.IdentityVerificationStatus IdentityCheckStatus
        {
            get { return identityCheckStatus_; }
            set
            {
                identityCheckStatus_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountBlob);
        }

        public bool Equals(AccountBlob other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Id != other.Id) return false;
            if (Region != other.Region) return false;
            if (!email_.Equals(other.email_)) return false;
            if (Flags != other.Flags) return false;
            if (SecureRelease != other.SecureRelease) return false;
            if (WhitelistStart != other.WhitelistStart) return false;
            if (WhitelistEnd != other.WhitelistEnd) return false;
            if (FullName != other.FullName) return false;
            if (!licenses_.Equals(other.licenses_)) return false;
            if (!credentials_.Equals(other.credentials_)) return false;
            if (!accountLinks_.Equals(other.accountLinks_)) return false;
            if (BattleTag != other.BattleTag) return false;
            if (DefaultCurrency != other.DefaultCurrency) return false;
            if (LegalRegion != other.LegalRegion) return false;
            if (LegalLocale != other.LegalLocale) return false;
            if (CacheExpiration != other.CacheExpiration) return false;
            if (!object.Equals(ParentalControlInfo, other.ParentalControlInfo)) return false;
            if (Country != other.Country) return false;
            if (PreferredRegion != other.PreferredRegion) return false;
            if (IdentityCheckStatus != other.IdentityCheckStatus) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Id != 0) hash ^= Id.GetHashCode();
            if (Region != 0) hash ^= Region.GetHashCode();
            hash ^= email_.GetHashCode();
            if (Flags != 0UL) hash ^= Flags.GetHashCode();
            if (SecureRelease != 0UL) hash ^= SecureRelease.GetHashCode();
            if (WhitelistStart != 0UL) hash ^= WhitelistStart.GetHashCode();
            if (WhitelistEnd != 0UL) hash ^= WhitelistEnd.GetHashCode();
            if (FullName.Length != 0) hash ^= FullName.GetHashCode();
            hash ^= licenses_.GetHashCode();
            hash ^= credentials_.GetHashCode();
            hash ^= accountLinks_.GetHashCode();
            if (BattleTag.Length != 0) hash ^= BattleTag.GetHashCode();
            if (DefaultCurrency != 0) hash ^= DefaultCurrency.GetHashCode();
            if (LegalRegion != 0) hash ^= LegalRegion.GetHashCode();
            if (LegalLocale != 0) hash ^= LegalLocale.GetHashCode();
            if (CacheExpiration != 0UL) hash ^= CacheExpiration.GetHashCode();
            if (parentalControlInfo_ != null) hash ^= ParentalControlInfo.GetHashCode();
            if (Country.Length != 0) hash ^= Country.GetHashCode();
            if (PreferredRegion != 0) hash ^= PreferredRegion.GetHashCode();
            if (IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA) hash ^= IdentityCheckStatus.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Id != 0)
            {
                output.WriteRawTag(21);
                output.WriteFixed32(Id);
            }
            if (Region != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(Region);
            }
            email_.WriteTo(output, _repeated_email_codec);
            if (Flags != 0UL)
            {
                output.WriteRawTag(40);
                output.WriteUInt64(Flags);
            }
            if (SecureRelease != 0UL)
            {
                output.WriteRawTag(48);
                output.WriteUInt64(SecureRelease);
            }
            if (WhitelistStart != 0UL)
            {
                output.WriteRawTag(56);
                output.WriteUInt64(WhitelistStart);
            }
            if (WhitelistEnd != 0UL)
            {
                output.WriteRawTag(64);
                output.WriteUInt64(WhitelistEnd);
            }
            if (FullName.Length != 0)
            {
                output.WriteRawTag(82);
                output.WriteString(FullName);
            }
            licenses_.WriteTo(output, _repeated_licenses_codec);
            credentials_.WriteTo(output, _repeated_credentials_codec);
            accountLinks_.WriteTo(output, _repeated_accountLinks_codec);
            if (BattleTag.Length != 0)
            {
                output.WriteRawTag(186, 1);
                output.WriteString(BattleTag);
            }
            if (DefaultCurrency != 0)
            {
                output.WriteRawTag(205, 1);
                output.WriteFixed32(DefaultCurrency);
            }
            if (LegalRegion != 0)
            {
                output.WriteRawTag(208, 1);
                output.WriteUInt32(LegalRegion);
            }
            if (LegalLocale != 0)
            {
                output.WriteRawTag(221, 1);
                output.WriteFixed32(LegalLocale);
            }
            if (CacheExpiration != 0UL)
            {
                output.WriteRawTag(240, 1);
                output.WriteUInt64(CacheExpiration);
            }
            if (parentalControlInfo_ != null)
            {
                output.WriteRawTag(250, 1);
                output.WriteMessage(ParentalControlInfo);
            }
            if (Country.Length != 0)
            {
                output.WriteRawTag(130, 2);
                output.WriteString(Country);
            }
            if (PreferredRegion != 0)
            {
                output.WriteRawTag(136, 2);
                output.WriteUInt32(PreferredRegion);
            }
            if (IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA)
            {
                output.WriteRawTag(144, 2);
                output.WriteEnum((int)IdentityCheckStatus);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Id != 0)
            {
                size += 1 + 4;
            }
            if (Region != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Region);
            }
            size += email_.CalculateSize(_repeated_email_codec);
            if (Flags != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Flags);
            }
            if (SecureRelease != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(SecureRelease);
            }
            if (WhitelistStart != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(WhitelistStart);
            }
            if (WhitelistEnd != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(WhitelistEnd);
            }
            if (FullName.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(FullName);
            }
            size += licenses_.CalculateSize(_repeated_licenses_codec);
            size += credentials_.CalculateSize(_repeated_credentials_codec);
            size += accountLinks_.CalculateSize(_repeated_accountLinks_codec);
            if (BattleTag.Length != 0)
            {
                size += 2 + pb::CodedOutputStream.ComputeStringSize(BattleTag);
            }
            if (DefaultCurrency != 0)
            {
                size += 2 + 4;
            }
            if (LegalRegion != 0)
            {
                size += 2 + pb::CodedOutputStream.ComputeUInt32Size(LegalRegion);
            }
            if (LegalLocale != 0)
            {
                size += 2 + 4;
            }
            if (CacheExpiration != 0UL)
            {
                size += 2 + pb::CodedOutputStream.ComputeUInt64Size(CacheExpiration);
            }
            if (parentalControlInfo_ != null)
            {
                size += 2 + pb::CodedOutputStream.ComputeMessageSize(ParentalControlInfo);
            }
            if (Country.Length != 0)
            {
                size += 2 + pb::CodedOutputStream.ComputeStringSize(Country);
            }
            if (PreferredRegion != 0)
            {
                size += 2 + pb::CodedOutputStream.ComputeUInt32Size(PreferredRegion);
            }
            if (IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA)
            {
                size += 2 + pb::CodedOutputStream.ComputeEnumSize((int)IdentityCheckStatus);
            }
            return size;
        }

        public void MergeFrom(AccountBlob other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Id != 0)
            {
                Id = other.Id;
            }
            if (other.Region != 0)
            {
                Region = other.Region;
            }
            email_.Add(other.email_);
            if (other.Flags != 0UL)
            {
                Flags = other.Flags;
            }
            if (other.SecureRelease != 0UL)
            {
                SecureRelease = other.SecureRelease;
            }
            if (other.WhitelistStart != 0UL)
            {
                WhitelistStart = other.WhitelistStart;
            }
            if (other.WhitelistEnd != 0UL)
            {
                WhitelistEnd = other.WhitelistEnd;
            }
            if (other.FullName.Length != 0)
            {
                FullName = other.FullName;
            }
            licenses_.Add(other.licenses_);
            credentials_.Add(other.credentials_);
            accountLinks_.Add(other.accountLinks_);
            if (other.BattleTag.Length != 0)
            {
                BattleTag = other.BattleTag;
            }
            if (other.DefaultCurrency != 0)
            {
                DefaultCurrency = other.DefaultCurrency;
            }
            if (other.LegalRegion != 0)
            {
                LegalRegion = other.LegalRegion;
            }
            if (other.LegalLocale != 0)
            {
                LegalLocale = other.LegalLocale;
            }
            if (other.CacheExpiration != 0UL)
            {
                CacheExpiration = other.CacheExpiration;
            }
            if (other.parentalControlInfo_ != null)
            {
                if (parentalControlInfo_ == null)
                {
                    parentalControlInfo_ = new Bgs.Protocol.Account.V1.ParentalControlInfo();
                }
                ParentalControlInfo.MergeFrom(other.ParentalControlInfo);
            }
            if (other.Country.Length != 0)
            {
                Country = other.Country;
            }
            if (other.PreferredRegion != 0)
            {
                PreferredRegion = other.PreferredRegion;
            }
            if (other.IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA)
            {
                IdentityCheckStatus = other.IdentityCheckStatus;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 21:
                        {
                            Id = input.ReadFixed32();
                            break;
                        }
                    case 24:
                        {
                            Region = input.ReadUInt32();
                            break;
                        }
                    case 34:
                        {
                            email_.AddEntriesFrom(input, _repeated_email_codec);
                            break;
                        }
                    case 40:
                        {
                            Flags = input.ReadUInt64();
                            break;
                        }
                    case 48:
                        {
                            SecureRelease = input.ReadUInt64();
                            break;
                        }
                    case 56:
                        {
                            WhitelistStart = input.ReadUInt64();
                            break;
                        }
                    case 64:
                        {
                            WhitelistEnd = input.ReadUInt64();
                            break;
                        }
                    case 82:
                        {
                            FullName = input.ReadString();
                            break;
                        }
                    case 162:
                        {
                            licenses_.AddEntriesFrom(input, _repeated_licenses_codec);
                            break;
                        }
                    case 170:
                        {
                            credentials_.AddEntriesFrom(input, _repeated_credentials_codec);
                            break;
                        }
                    case 178:
                        {
                            accountLinks_.AddEntriesFrom(input, _repeated_accountLinks_codec);
                            break;
                        }
                    case 186:
                        {
                            BattleTag = input.ReadString();
                            break;
                        }
                    case 205:
                        {
                            DefaultCurrency = input.ReadFixed32();
                            break;
                        }
                    case 208:
                        {
                            LegalRegion = input.ReadUInt32();
                            break;
                        }
                    case 221:
                        {
                            LegalLocale = input.ReadFixed32();
                            break;
                        }
                    case 240:
                        {
                            CacheExpiration = input.ReadUInt64();
                            break;
                        }
                    case 250:
                        {
                            if (parentalControlInfo_ == null)
                            {
                                parentalControlInfo_ = new Bgs.Protocol.Account.V1.ParentalControlInfo();
                            }
                            input.ReadMessage(parentalControlInfo_);
                            break;
                        }
                    case 258:
                        {
                            Country = input.ReadString();
                            break;
                        }
                    case 264:
                        {
                            PreferredRegion = input.ReadUInt32();
                            break;
                        }
                    case 272:
                        {
                            identityCheckStatus_ = (Bgs.Protocol.Account.V1.IdentityVerificationStatus)input.ReadEnum();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountBlobList : pb::IMessage<AccountBlobList>
    {
        private static readonly pb::MessageParser<AccountBlobList> _parser = new pb::MessageParser<AccountBlobList>(() => new AccountBlobList());
        public static pb::MessageParser<AccountBlobList> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[4]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountBlobList()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountBlobList(AccountBlobList other) : this()
        {
            blob_ = other.blob_.Clone();
        }

        public AccountBlobList Clone()
        {
            return new AccountBlobList(this);
        }

        /// <summary>Field number for the "blob" field.</summary>
        public const int BlobFieldNumber = 1;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.AccountBlob> _repeated_blob_codec
            = pb::FieldCodec.ForMessage(10, Bgs.Protocol.Account.V1.AccountBlob.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountBlob> blob_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountBlob>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountBlob> Blob
        {
            get { return blob_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountBlobList);
        }

        public bool Equals(AccountBlobList other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!blob_.Equals(other.blob_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            hash ^= blob_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            blob_.WriteTo(output, _repeated_blob_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            size += blob_.CalculateSize(_repeated_blob_codec);
            return size;
        }

        public void MergeFrom(AccountBlobList other)
        {
            if (other == null)
            {
                return;
            }
            blob_.Add(other.blob_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            blob_.AddEntriesFrom(input, _repeated_blob_codec);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountHandle : pb::IMessage<GameAccountHandle>
    {
        private static readonly pb::MessageParser<GameAccountHandle> _parser = new pb::MessageParser<GameAccountHandle>(() => new GameAccountHandle());
        public static pb::MessageParser<GameAccountHandle> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[5]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountHandle()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountHandle(GameAccountHandle other) : this()
        {
            id_ = other.id_;
            program_ = other.program_;
            region_ = other.region_;
        }

        public GameAccountHandle Clone()
        {
            return new GameAccountHandle(this);
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 1;
        private uint id_;
        public uint Id
        {
            get { return id_; }
            set
            {
                id_ = value;
            }
        }

        /// <summary>Field number for the "program" field.</summary>
        public const int ProgramFieldNumber = 2;
        private uint program_;
        public uint Program
        {
            get { return program_; }
            set
            {
                program_ = value;
            }
        }

        /// <summary>Field number for the "region" field.</summary>
        public const int RegionFieldNumber = 3;
        private uint region_;
        public uint Region
        {
            get { return region_; }
            set
            {
                region_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountHandle);
        }

        public bool Equals(GameAccountHandle other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Id != other.Id) return false;
            if (Program != other.Program) return false;
            if (Region != other.Region) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Id != 0) hash ^= Id.GetHashCode();
            if (Program != 0) hash ^= Program.GetHashCode();
            if (Region != 0) hash ^= Region.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Id != 0)
            {
                output.WriteRawTag(13);
                output.WriteFixed32(Id);
            }
            if (Program != 0)
            {
                output.WriteRawTag(21);
                output.WriteFixed32(Program);
            }
            if (Region != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(Region);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Id != 0)
            {
                size += 1 + 4;
            }
            if (Program != 0)
            {
                size += 1 + 4;
            }
            if (Region != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Region);
            }
            return size;
        }

        public void MergeFrom(GameAccountHandle other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Id != 0)
            {
                Id = other.Id;
            }
            if (other.Program != 0)
            {
                Program = other.Program;
            }
            if (other.Region != 0)
            {
                Region = other.Region;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 13:
                        {
                            Id = input.ReadFixed32();
                            break;
                        }
                    case 21:
                        {
                            Program = input.ReadFixed32();
                            break;
                        }
                    case 24:
                        {
                            Region = input.ReadUInt32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountLink : pb::IMessage<GameAccountLink>
    {
        private static readonly pb::MessageParser<GameAccountLink> _parser = new pb::MessageParser<GameAccountLink>(() => new GameAccountLink());
        public static pb::MessageParser<GameAccountLink> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[6]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountLink()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountLink(GameAccountLink other) : this()
        {
            GameAccount = other.gameAccount_ != null ? other.GameAccount.Clone() : null;
            name_ = other.name_;
        }

        public GameAccountLink Clone()
        {
            return new GameAccountLink(this);
        }

        /// <summary>Field number for the "game_account" field.</summary>
        public const int GameAccountFieldNumber = 1;
        private Bgs.Protocol.Account.V1.GameAccountHandle gameAccount_;
        public Bgs.Protocol.Account.V1.GameAccountHandle GameAccount
        {
            get { return gameAccount_; }
            set
            {
                gameAccount_ = value;
            }
        }

        /// <summary>Field number for the "name" field.</summary>
        public const int NameFieldNumber = 2;
        private string name_ = "";
        public string Name
        {
            get { return name_; }
            set
            {
                name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountLink);
        }

        public bool Equals(GameAccountLink other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(GameAccount, other.GameAccount)) return false;
            if (Name != other.Name) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (gameAccount_ != null) hash ^= GameAccount.GetHashCode();
            if (Name.Length != 0) hash ^= Name.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (gameAccount_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(GameAccount);
            }
            if (Name.Length != 0)
            {
                output.WriteRawTag(18);
                output.WriteString(Name);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (gameAccount_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccount);
            }
            if (Name.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
            }
            return size;
        }

        public void MergeFrom(GameAccountLink other)
        {
            if (other == null)
            {
                return;
            }
            if (other.gameAccount_ != null)
            {
                if (gameAccount_ == null)
                {
                    gameAccount_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                }
                GameAccount.MergeFrom(other.GameAccount);
            }
            if (other.Name.Length != 0)
            {
                Name = other.Name;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (gameAccount_ == null)
                            {
                                gameAccount_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                            }
                            input.ReadMessage(gameAccount_);
                            break;
                        }
                    case 18:
                        {
                            Name = input.ReadString();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountBlob : pb::IMessage<GameAccountBlob>
    {
        private static readonly pb::MessageParser<GameAccountBlob> _parser = new pb::MessageParser<GameAccountBlob>(() => new GameAccountBlob());
        public static pb::MessageParser<GameAccountBlob> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[7]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountBlob()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountBlob(GameAccountBlob other) : this()
        {
            GameAccount = other.gameAccount_ != null ? other.GameAccount.Clone() : null;
            name_ = other.name_;
            realmPermissions_ = other.realmPermissions_;
            status_ = other.status_;
            flags_ = other.flags_;
            billingFlags_ = other.billingFlags_;
            cacheExpiration_ = other.cacheExpiration_;
            subscriptionExpiration_ = other.subscriptionExpiration_;
            unitsRemaining_ = other.unitsRemaining_;
            statusExpiration_ = other.statusExpiration_;
            boxLevel_ = other.boxLevel_;
            boxLevelExpiration_ = other.boxLevelExpiration_;
            licenses_ = other.licenses_.Clone();
            rafAccount_ = other.rafAccount_;
            rafInfo_ = other.rafInfo_;
            rafExpiration_ = other.rafExpiration_;
        }

        public GameAccountBlob Clone()
        {
            return new GameAccountBlob(this);
        }

        /// <summary>Field number for the "game_account" field.</summary>
        public const int GameAccountFieldNumber = 1;
        private Bgs.Protocol.Account.V1.GameAccountHandle gameAccount_;
        public Bgs.Protocol.Account.V1.GameAccountHandle GameAccount
        {
            get { return gameAccount_; }
            set
            {
                gameAccount_ = value;
            }
        }

        /// <summary>Field number for the "name" field.</summary>
        public const int NameFieldNumber = 2;
        private string name_ = "";
        public string Name
        {
            get { return name_; }
            set
            {
                name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "realm_permissions" field.</summary>
        public const int RealmPermissionsFieldNumber = 3;
        private uint realmPermissions_;
        public uint RealmPermissions
        {
            get { return realmPermissions_; }
            set
            {
                realmPermissions_ = value;
            }
        }

        /// <summary>Field number for the "status" field.</summary>
        public const int StatusFieldNumber = 4;
        private uint status_;
        public uint Status
        {
            get { return status_; }
            set
            {
                status_ = value;
            }
        }

        /// <summary>Field number for the "flags" field.</summary>
        public const int FlagsFieldNumber = 5;
        private ulong flags_;
        public ulong Flags
        {
            get { return flags_; }
            set
            {
                flags_ = value;
            }
        }

        /// <summary>Field number for the "billing_flags" field.</summary>
        public const int BillingFlagsFieldNumber = 6;
        private uint billingFlags_;
        public uint BillingFlags
        {
            get { return billingFlags_; }
            set
            {
                billingFlags_ = value;
            }
        }

        /// <summary>Field number for the "cache_expiration" field.</summary>
        public const int CacheExpirationFieldNumber = 7;
        private ulong cacheExpiration_;
        public ulong CacheExpiration
        {
            get { return cacheExpiration_; }
            set
            {
                cacheExpiration_ = value;
            }
        }

        /// <summary>Field number for the "subscription_expiration" field.</summary>
        public const int SubscriptionExpirationFieldNumber = 10;
        private ulong subscriptionExpiration_;
        public ulong SubscriptionExpiration
        {
            get { return subscriptionExpiration_; }
            set
            {
                subscriptionExpiration_ = value;
            }
        }

        /// <summary>Field number for the "units_remaining" field.</summary>
        public const int UnitsRemainingFieldNumber = 11;
        private uint unitsRemaining_;
        public uint UnitsRemaining
        {
            get { return unitsRemaining_; }
            set
            {
                unitsRemaining_ = value;
            }
        }

        /// <summary>Field number for the "status_expiration" field.</summary>
        public const int StatusExpirationFieldNumber = 12;
        private ulong statusExpiration_;
        public ulong StatusExpiration
        {
            get { return statusExpiration_; }
            set
            {
                statusExpiration_ = value;
            }
        }

        /// <summary>Field number for the "box_level" field.</summary>
        public const int BoxLevelFieldNumber = 13;
        private uint boxLevel_;
        public uint BoxLevel
        {
            get { return boxLevel_; }
            set
            {
                boxLevel_ = value;
            }
        }

        /// <summary>Field number for the "box_level_expiration" field.</summary>
        public const int BoxLevelExpirationFieldNumber = 14;
        private ulong boxLevelExpiration_;
        public ulong BoxLevelExpiration
        {
            get { return boxLevelExpiration_; }
            set
            {
                boxLevelExpiration_ = value;
            }
        }

        /// <summary>Field number for the "licenses" field.</summary>
        public const int LicensesFieldNumber = 20;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.AccountLicense> _repeated_licenses_codec
            = pb::FieldCodec.ForMessage(162, Bgs.Protocol.Account.V1.AccountLicense.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> licenses_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> Licenses
        {
            get { return licenses_; }
        }

        /// <summary>Field number for the "raf_account" field.</summary>
        public const int RafAccountFieldNumber = 21;
        private uint rafAccount_;
        public uint RafAccount
        {
            get { return rafAccount_; }
            set
            {
                rafAccount_ = value;
            }
        }

        /// <summary>Field number for the "raf_info" field.</summary>
        public const int RafInfoFieldNumber = 22;
        private pb::ByteString rafInfo_ = pb::ByteString.Empty;
        public pb::ByteString RafInfo
        {
            get { return rafInfo_; }
            set
            {
                rafInfo_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "raf_expiration" field.</summary>
        public const int RafExpirationFieldNumber = 23;
        private ulong rafExpiration_;
        public ulong RafExpiration
        {
            get { return rafExpiration_; }
            set
            {
                rafExpiration_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountBlob);
        }

        public bool Equals(GameAccountBlob other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(GameAccount, other.GameAccount)) return false;
            if (Name != other.Name) return false;
            if (RealmPermissions != other.RealmPermissions) return false;
            if (Status != other.Status) return false;
            if (Flags != other.Flags) return false;
            if (BillingFlags != other.BillingFlags) return false;
            if (CacheExpiration != other.CacheExpiration) return false;
            if (SubscriptionExpiration != other.SubscriptionExpiration) return false;
            if (UnitsRemaining != other.UnitsRemaining) return false;
            if (StatusExpiration != other.StatusExpiration) return false;
            if (BoxLevel != other.BoxLevel) return false;
            if (BoxLevelExpiration != other.BoxLevelExpiration) return false;
            if (!licenses_.Equals(other.licenses_)) return false;
            if (RafAccount != other.RafAccount) return false;
            if (RafInfo != other.RafInfo) return false;
            if (RafExpiration != other.RafExpiration) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (gameAccount_ != null) hash ^= GameAccount.GetHashCode();
            if (Name.Length != 0) hash ^= Name.GetHashCode();
            if (RealmPermissions != 0) hash ^= RealmPermissions.GetHashCode();
            if (Status != 0) hash ^= Status.GetHashCode();
            if (Flags != 0UL) hash ^= Flags.GetHashCode();
            if (BillingFlags != 0) hash ^= BillingFlags.GetHashCode();
            if (CacheExpiration != 0UL) hash ^= CacheExpiration.GetHashCode();
            if (SubscriptionExpiration != 0UL) hash ^= SubscriptionExpiration.GetHashCode();
            if (UnitsRemaining != 0) hash ^= UnitsRemaining.GetHashCode();
            if (StatusExpiration != 0UL) hash ^= StatusExpiration.GetHashCode();
            if (BoxLevel != 0) hash ^= BoxLevel.GetHashCode();
            if (BoxLevelExpiration != 0UL) hash ^= BoxLevelExpiration.GetHashCode();
            hash ^= licenses_.GetHashCode();
            if (RafAccount != 0) hash ^= RafAccount.GetHashCode();
            if (RafInfo.Length != 0) hash ^= RafInfo.GetHashCode();
            if (RafExpiration != 0UL) hash ^= RafExpiration.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (gameAccount_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(GameAccount);
            }
            if (Name.Length != 0)
            {
                output.WriteRawTag(18);
                output.WriteString(Name);
            }
            if (RealmPermissions != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(RealmPermissions);
            }
            if (Status != 0)
            {
                output.WriteRawTag(32);
                output.WriteUInt32(Status);
            }
            if (Flags != 0UL)
            {
                output.WriteRawTag(40);
                output.WriteUInt64(Flags);
            }
            if (BillingFlags != 0)
            {
                output.WriteRawTag(48);
                output.WriteUInt32(BillingFlags);
            }
            if (CacheExpiration != 0UL)
            {
                output.WriteRawTag(56);
                output.WriteUInt64(CacheExpiration);
            }
            if (SubscriptionExpiration != 0UL)
            {
                output.WriteRawTag(80);
                output.WriteUInt64(SubscriptionExpiration);
            }
            if (UnitsRemaining != 0)
            {
                output.WriteRawTag(88);
                output.WriteUInt32(UnitsRemaining);
            }
            if (StatusExpiration != 0UL)
            {
                output.WriteRawTag(96);
                output.WriteUInt64(StatusExpiration);
            }
            if (BoxLevel != 0)
            {
                output.WriteRawTag(104);
                output.WriteUInt32(BoxLevel);
            }
            if (BoxLevelExpiration != 0UL)
            {
                output.WriteRawTag(112);
                output.WriteUInt64(BoxLevelExpiration);
            }
            licenses_.WriteTo(output, _repeated_licenses_codec);
            if (RafAccount != 0)
            {
                output.WriteRawTag(173, 1);
                output.WriteFixed32(RafAccount);
            }
            if (RafInfo.Length != 0)
            {
                output.WriteRawTag(178, 1);
                output.WriteBytes(RafInfo);
            }
            if (RafExpiration != 0UL)
            {
                output.WriteRawTag(184, 1);
                output.WriteUInt64(RafExpiration);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (gameAccount_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccount);
            }
            if (Name.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
            }
            if (RealmPermissions != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RealmPermissions);
            }
            if (Status != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Status);
            }
            if (Flags != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Flags);
            }
            if (BillingFlags != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BillingFlags);
            }
            if (CacheExpiration != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(CacheExpiration);
            }
            if (SubscriptionExpiration != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(SubscriptionExpiration);
            }
            if (UnitsRemaining != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(UnitsRemaining);
            }
            if (StatusExpiration != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(StatusExpiration);
            }
            if (BoxLevel != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BoxLevel);
            }
            if (BoxLevelExpiration != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(BoxLevelExpiration);
            }
            size += licenses_.CalculateSize(_repeated_licenses_codec);
            if (RafAccount != 0)
            {
                size += 2 + 4;
            }
            if (RafInfo.Length != 0)
            {
                size += 2 + pb::CodedOutputStream.ComputeBytesSize(RafInfo);
            }
            if (RafExpiration != 0UL)
            {
                size += 2 + pb::CodedOutputStream.ComputeUInt64Size(RafExpiration);
            }
            return size;
        }

        public void MergeFrom(GameAccountBlob other)
        {
            if (other == null)
            {
                return;
            }
            if (other.gameAccount_ != null)
            {
                if (gameAccount_ == null)
                {
                    gameAccount_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                }
                GameAccount.MergeFrom(other.GameAccount);
            }
            if (other.Name.Length != 0)
            {
                Name = other.Name;
            }
            if (other.RealmPermissions != 0)
            {
                RealmPermissions = other.RealmPermissions;
            }
            if (other.Status != 0)
            {
                Status = other.Status;
            }
            if (other.Flags != 0UL)
            {
                Flags = other.Flags;
            }
            if (other.BillingFlags != 0)
            {
                BillingFlags = other.BillingFlags;
            }
            if (other.CacheExpiration != 0UL)
            {
                CacheExpiration = other.CacheExpiration;
            }
            if (other.SubscriptionExpiration != 0UL)
            {
                SubscriptionExpiration = other.SubscriptionExpiration;
            }
            if (other.UnitsRemaining != 0)
            {
                UnitsRemaining = other.UnitsRemaining;
            }
            if (other.StatusExpiration != 0UL)
            {
                StatusExpiration = other.StatusExpiration;
            }
            if (other.BoxLevel != 0)
            {
                BoxLevel = other.BoxLevel;
            }
            if (other.BoxLevelExpiration != 0UL)
            {
                BoxLevelExpiration = other.BoxLevelExpiration;
            }
            licenses_.Add(other.licenses_);
            if (other.RafAccount != 0)
            {
                RafAccount = other.RafAccount;
            }
            if (other.RafInfo.Length != 0)
            {
                RafInfo = other.RafInfo;
            }
            if (other.RafExpiration != 0UL)
            {
                RafExpiration = other.RafExpiration;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (gameAccount_ == null)
                            {
                                gameAccount_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                            }
                            input.ReadMessage(gameAccount_);
                            break;
                        }
                    case 18:
                        {
                            Name = input.ReadString();
                            break;
                        }
                    case 24:
                        {
                            RealmPermissions = input.ReadUInt32();
                            break;
                        }
                    case 32:
                        {
                            Status = input.ReadUInt32();
                            break;
                        }
                    case 40:
                        {
                            Flags = input.ReadUInt64();
                            break;
                        }
                    case 48:
                        {
                            BillingFlags = input.ReadUInt32();
                            break;
                        }
                    case 56:
                        {
                            CacheExpiration = input.ReadUInt64();
                            break;
                        }
                    case 80:
                        {
                            SubscriptionExpiration = input.ReadUInt64();
                            break;
                        }
                    case 88:
                        {
                            UnitsRemaining = input.ReadUInt32();
                            break;
                        }
                    case 96:
                        {
                            StatusExpiration = input.ReadUInt64();
                            break;
                        }
                    case 104:
                        {
                            BoxLevel = input.ReadUInt32();
                            break;
                        }
                    case 112:
                        {
                            BoxLevelExpiration = input.ReadUInt64();
                            break;
                        }
                    case 162:
                        {
                            licenses_.AddEntriesFrom(input, _repeated_licenses_codec);
                            break;
                        }
                    case 173:
                        {
                            RafAccount = input.ReadFixed32();
                            break;
                        }
                    case 178:
                        {
                            RafInfo = input.ReadBytes();
                            break;
                        }
                    case 184:
                        {
                            RafExpiration = input.ReadUInt64();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountBlobList : pb::IMessage<GameAccountBlobList>
    {
        private static readonly pb::MessageParser<GameAccountBlobList> _parser = new pb::MessageParser<GameAccountBlobList>(() => new GameAccountBlobList());
        public static pb::MessageParser<GameAccountBlobList> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[8]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountBlobList()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountBlobList(GameAccountBlobList other) : this()
        {
            blob_ = other.blob_.Clone();
        }

        public GameAccountBlobList Clone()
        {
            return new GameAccountBlobList(this);
        }

        /// <summary>Field number for the "blob" field.</summary>
        public const int BlobFieldNumber = 1;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.GameAccountBlob> _repeated_blob_codec
            = pb::FieldCodec.ForMessage(10, Bgs.Protocol.Account.V1.GameAccountBlob.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountBlob> blob_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountBlob>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountBlob> Blob
        {
            get { return blob_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountBlobList);
        }

        public bool Equals(GameAccountBlobList other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!blob_.Equals(other.blob_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            hash ^= blob_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            blob_.WriteTo(output, _repeated_blob_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            size += blob_.CalculateSize(_repeated_blob_codec);
            return size;
        }

        public void MergeFrom(GameAccountBlobList other)
        {
            if (other == null)
            {
                return;
            }
            blob_.Add(other.blob_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            blob_.AddEntriesFrom(input, _repeated_blob_codec);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountReference : pb::IMessage<AccountReference>
    {
        private static readonly pb::MessageParser<AccountReference> _parser = new pb::MessageParser<AccountReference>(() => new AccountReference());
        public static pb::MessageParser<AccountReference> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[9]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountReference()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountReference(AccountReference other) : this()
        {
            id_ = other.id_;
            email_ = other.email_;
            Handle = other.handle_ != null ? other.Handle.Clone() : null;
            battleTag_ = other.battleTag_;
            region_ = other.region_;
        }

        public AccountReference Clone()
        {
            return new AccountReference(this);
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 1;
        private uint id_;
        public uint Id
        {
            get { return id_; }
            set
            {
                id_ = value;
            }
        }

        /// <summary>Field number for the "email" field.</summary>
        public const int EmailFieldNumber = 2;
        private string email_ = "";
        public string Email
        {
            get { return email_; }
            set
            {
                email_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "handle" field.</summary>
        public const int HandleFieldNumber = 3;
        private Bgs.Protocol.Account.V1.GameAccountHandle handle_;
        public Bgs.Protocol.Account.V1.GameAccountHandle Handle
        {
            get { return handle_; }
            set
            {
                handle_ = value;
            }
        }

        /// <summary>Field number for the "battle_tag" field.</summary>
        public const int BattleTagFieldNumber = 4;
        private string battleTag_ = "";
        public string BattleTag
        {
            get { return battleTag_; }
            set
            {
                battleTag_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "region" field.</summary>
        public const int RegionFieldNumber = 10;
        private uint region_;
        public uint Region
        {
            get { return region_; }
            set
            {
                region_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountReference);
        }

        public bool Equals(AccountReference other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Id != other.Id) return false;
            if (Email != other.Email) return false;
            if (!object.Equals(Handle, other.Handle)) return false;
            if (BattleTag != other.BattleTag) return false;
            if (Region != other.Region) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Id != 0) hash ^= Id.GetHashCode();
            if (Email.Length != 0) hash ^= Email.GetHashCode();
            if (handle_ != null) hash ^= Handle.GetHashCode();
            if (BattleTag.Length != 0) hash ^= BattleTag.GetHashCode();
            if (Region != 0) hash ^= Region.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Id != 0)
            {
                output.WriteRawTag(13);
                output.WriteFixed32(Id);
            }
            if (Email.Length != 0)
            {
                output.WriteRawTag(18);
                output.WriteString(Email);
            }
            if (handle_ != null)
            {
                output.WriteRawTag(26);
                output.WriteMessage(Handle);
            }
            if (BattleTag.Length != 0)
            {
                output.WriteRawTag(34);
                output.WriteString(BattleTag);
            }
            if (Region != 0)
            {
                output.WriteRawTag(80);
                output.WriteUInt32(Region);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Id != 0)
            {
                size += 1 + 4;
            }
            if (Email.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Email);
            }
            if (handle_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle);
            }
            if (BattleTag.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(BattleTag);
            }
            if (Region != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Region);
            }
            return size;
        }

        public void MergeFrom(AccountReference other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Id != 0)
            {
                Id = other.Id;
            }
            if (other.Email.Length != 0)
            {
                Email = other.Email;
            }
            if (other.handle_ != null)
            {
                if (handle_ == null)
                {
                    handle_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                }
                Handle.MergeFrom(other.Handle);
            }
            if (other.BattleTag.Length != 0)
            {
                BattleTag = other.BattleTag;
            }
            if (other.Region != 0)
            {
                Region = other.Region;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 13:
                        {
                            Id = input.ReadFixed32();
                            break;
                        }
                    case 18:
                        {
                            Email = input.ReadString();
                            break;
                        }
                    case 26:
                        {
                            if (handle_ == null)
                            {
                                handle_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                            }
                            input.ReadMessage(handle_);
                            break;
                        }
                    case 34:
                        {
                            BattleTag = input.ReadString();
                            break;
                        }
                    case 80:
                        {
                            Region = input.ReadUInt32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Identity : pb::IMessage<Identity>
    {
        private static readonly pb::MessageParser<Identity> _parser = new pb::MessageParser<Identity>(() => new Identity());
        public static pb::MessageParser<Identity> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[10]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public Identity()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public Identity(Identity other) : this()
        {
            Account = other.account_ != null ? other.Account.Clone() : null;
            GameAccount = other.gameAccount_ != null ? other.GameAccount.Clone() : null;
            Process = other.process_ != null ? other.Process.Clone() : null;
        }

        public Identity Clone()
        {
            return new Identity(this);
        }

        /// <summary>Field number for the "account" field.</summary>
        public const int AccountFieldNumber = 1;
        private Bgs.Protocol.Account.V1.AccountId account_;
        public Bgs.Protocol.Account.V1.AccountId Account
        {
            get { return account_; }
            set
            {
                account_ = value;
            }
        }

        /// <summary>Field number for the "game_account" field.</summary>
        public const int GameAccountFieldNumber = 2;
        private Bgs.Protocol.Account.V1.GameAccountHandle gameAccount_;
        public Bgs.Protocol.Account.V1.GameAccountHandle GameAccount
        {
            get { return gameAccount_; }
            set
            {
                gameAccount_ = value;
            }
        }

        /// <summary>Field number for the "process" field.</summary>
        public const int ProcessFieldNumber = 3;
        private Bgs.Protocol.ProcessId process_;
        public Bgs.Protocol.ProcessId Process
        {
            get { return process_; }
            set
            {
                process_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as Identity);
        }

        public bool Equals(Identity other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(Account, other.Account)) return false;
            if (!object.Equals(GameAccount, other.GameAccount)) return false;
            if (!object.Equals(Process, other.Process)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (account_ != null) hash ^= Account.GetHashCode();
            if (gameAccount_ != null) hash ^= GameAccount.GetHashCode();
            if (process_ != null) hash ^= Process.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (account_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(Account);
            }
            if (gameAccount_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(GameAccount);
            }
            if (process_ != null)
            {
                output.WriteRawTag(26);
                output.WriteMessage(Process);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (account_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(Account);
            }
            if (gameAccount_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccount);
            }
            if (process_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(Process);
            }
            return size;
        }

        public void MergeFrom(Identity other)
        {
            if (other == null)
            {
                return;
            }
            if (other.account_ != null)
            {
                if (account_ == null)
                {
                    account_ = new Bgs.Protocol.Account.V1.AccountId();
                }
                Account.MergeFrom(other.Account);
            }
            if (other.gameAccount_ != null)
            {
                if (gameAccount_ == null)
                {
                    gameAccount_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                }
                GameAccount.MergeFrom(other.GameAccount);
            }
            if (other.process_ != null)
            {
                if (process_ == null)
                {
                    process_ = new Bgs.Protocol.ProcessId();
                }
                Process.MergeFrom(other.Process);
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (account_ == null)
                            {
                                account_ = new Bgs.Protocol.Account.V1.AccountId();
                            }
                            input.ReadMessage(account_);
                            break;
                        }
                    case 18:
                        {
                            if (gameAccount_ == null)
                            {
                                gameAccount_ = new Bgs.Protocol.Account.V1.GameAccountHandle();
                            }
                            input.ReadMessage(gameAccount_);
                            break;
                        }
                    case 26:
                        {
                            if (process_ == null)
                            {
                                process_ = new Bgs.Protocol.ProcessId();
                            }
                            input.ReadMessage(process_);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class ProgramTag : pb::IMessage<ProgramTag>
    {
        private static readonly pb::MessageParser<ProgramTag> _parser = new pb::MessageParser<ProgramTag>(() => new ProgramTag());
        public static pb::MessageParser<ProgramTag> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[11]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public ProgramTag()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public ProgramTag(ProgramTag other) : this()
        {
            program_ = other.program_;
            tag_ = other.tag_;
        }

        public ProgramTag Clone()
        {
            return new ProgramTag(this);
        }

        /// <summary>Field number for the "program" field.</summary>
        public const int ProgramFieldNumber = 1;
        private uint program_;
        public uint Program
        {
            get { return program_; }
            set
            {
                program_ = value;
            }
        }

        /// <summary>Field number for the "tag" field.</summary>
        public const int TagFieldNumber = 2;
        private uint tag_;
        public uint Tag
        {
            get { return tag_; }
            set
            {
                tag_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as ProgramTag);
        }

        public bool Equals(ProgramTag other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Program != other.Program) return false;
            if (Tag != other.Tag) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Program != 0) hash ^= Program.GetHashCode();
            if (Tag != 0) hash ^= Tag.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Program != 0)
            {
                output.WriteRawTag(13);
                output.WriteFixed32(Program);
            }
            if (Tag != 0)
            {
                output.WriteRawTag(21);
                output.WriteFixed32(Tag);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Program != 0)
            {
                size += 1 + 4;
            }
            if (Tag != 0)
            {
                size += 1 + 4;
            }
            return size;
        }

        public void MergeFrom(ProgramTag other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Program != 0)
            {
                Program = other.Program;
            }
            if (other.Tag != 0)
            {
                Tag = other.Tag;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 13:
                        {
                            Program = input.ReadFixed32();
                            break;
                        }
                    case 21:
                        {
                            Tag = input.ReadFixed32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class RegionTag : pb::IMessage<RegionTag>
    {
        private static readonly pb::MessageParser<RegionTag> _parser = new pb::MessageParser<RegionTag>(() => new RegionTag());
        public static pb::MessageParser<RegionTag> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[12]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public RegionTag()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public RegionTag(RegionTag other) : this()
        {
            region_ = other.region_;
            tag_ = other.tag_;
        }

        public RegionTag Clone()
        {
            return new RegionTag(this);
        }

        /// <summary>Field number for the "region" field.</summary>
        public const int RegionFieldNumber = 1;
        private uint region_;
        public uint Region
        {
            get { return region_; }
            set
            {
                region_ = value;
            }
        }

        /// <summary>Field number for the "tag" field.</summary>
        public const int TagFieldNumber = 2;
        private uint tag_;
        public uint Tag
        {
            get { return tag_; }
            set
            {
                tag_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as RegionTag);
        }

        public bool Equals(RegionTag other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Region != other.Region) return false;
            if (Tag != other.Tag) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Region != 0) hash ^= Region.GetHashCode();
            if (Tag != 0) hash ^= Tag.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Region != 0)
            {
                output.WriteRawTag(13);
                output.WriteFixed32(Region);
            }
            if (Tag != 0)
            {
                output.WriteRawTag(21);
                output.WriteFixed32(Tag);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Region != 0)
            {
                size += 1 + 4;
            }
            if (Tag != 0)
            {
                size += 1 + 4;
            }
            return size;
        }

        public void MergeFrom(RegionTag other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Region != 0)
            {
                Region = other.Region;
            }
            if (other.Tag != 0)
            {
                Tag = other.Tag;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 13:
                        {
                            Region = input.ReadFixed32();
                            break;
                        }
                    case 21:
                        {
                            Tag = input.ReadFixed32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountFieldTags : pb::IMessage<AccountFieldTags>
    {
        private static readonly pb::MessageParser<AccountFieldTags> _parser = new pb::MessageParser<AccountFieldTags>(() => new AccountFieldTags());
        public static pb::MessageParser<AccountFieldTags> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[13]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountFieldTags()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountFieldTags(AccountFieldTags other) : this()
        {
            accountLevelInfoTag_ = other.accountLevelInfoTag_;
            privacyInfoTag_ = other.privacyInfoTag_;
            parentalControlInfoTag_ = other.parentalControlInfoTag_;
            gameLevelInfoTags_ = other.gameLevelInfoTags_.Clone();
            gameStatusTags_ = other.gameStatusTags_.Clone();
            gameAccountTags_ = other.gameAccountTags_.Clone();
        }

        public AccountFieldTags Clone()
        {
            return new AccountFieldTags(this);
        }

        /// <summary>Field number for the "account_level_info_tag" field.</summary>
        public const int AccountLevelInfoTagFieldNumber = 2;
        private uint accountLevelInfoTag_;
        public uint AccountLevelInfoTag
        {
            get { return accountLevelInfoTag_; }
            set
            {
                accountLevelInfoTag_ = value;
            }
        }

        /// <summary>Field number for the "privacy_info_tag" field.</summary>
        public const int PrivacyInfoTagFieldNumber = 3;
        private uint privacyInfoTag_;
        public uint PrivacyInfoTag
        {
            get { return privacyInfoTag_; }
            set
            {
                privacyInfoTag_ = value;
            }
        }

        /// <summary>Field number for the "parental_control_info_tag" field.</summary>
        public const int ParentalControlInfoTagFieldNumber = 4;
        private uint parentalControlInfoTag_;
        public uint ParentalControlInfoTag
        {
            get { return parentalControlInfoTag_; }
            set
            {
                parentalControlInfoTag_ = value;
            }
        }

        /// <summary>Field number for the "game_level_info_tags" field.</summary>
        public const int GameLevelInfoTagsFieldNumber = 7;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.ProgramTag> _repeated_gameLevelInfoTags_codec
            = pb::FieldCodec.ForMessage(58, Bgs.Protocol.Account.V1.ProgramTag.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.ProgramTag> gameLevelInfoTags_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.ProgramTag>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.ProgramTag> GameLevelInfoTags
        {
            get { return gameLevelInfoTags_; }
        }

        /// <summary>Field number for the "game_status_tags" field.</summary>
        public const int GameStatusTagsFieldNumber = 9;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.ProgramTag> _repeated_gameStatusTags_codec
            = pb::FieldCodec.ForMessage(74, Bgs.Protocol.Account.V1.ProgramTag.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.ProgramTag> gameStatusTags_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.ProgramTag>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.ProgramTag> GameStatusTags
        {
            get { return gameStatusTags_; }
        }

        /// <summary>Field number for the "game_account_tags" field.</summary>
        public const int GameAccountTagsFieldNumber = 11;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.RegionTag> _repeated_gameAccountTags_codec
            = pb::FieldCodec.ForMessage(90, Bgs.Protocol.Account.V1.RegionTag.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.RegionTag> gameAccountTags_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.RegionTag>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.RegionTag> GameAccountTags
        {
            get { return gameAccountTags_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountFieldTags);
        }

        public bool Equals(AccountFieldTags other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (AccountLevelInfoTag != other.AccountLevelInfoTag) return false;
            if (PrivacyInfoTag != other.PrivacyInfoTag) return false;
            if (ParentalControlInfoTag != other.ParentalControlInfoTag) return false;
            if (!gameLevelInfoTags_.Equals(other.gameLevelInfoTags_)) return false;
            if (!gameStatusTags_.Equals(other.gameStatusTags_)) return false;
            if (!gameAccountTags_.Equals(other.gameAccountTags_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (AccountLevelInfoTag != 0) hash ^= AccountLevelInfoTag.GetHashCode();
            if (PrivacyInfoTag != 0) hash ^= PrivacyInfoTag.GetHashCode();
            if (ParentalControlInfoTag != 0) hash ^= ParentalControlInfoTag.GetHashCode();
            hash ^= gameLevelInfoTags_.GetHashCode();
            hash ^= gameStatusTags_.GetHashCode();
            hash ^= gameAccountTags_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (AccountLevelInfoTag != 0)
            {
                output.WriteRawTag(21);
                output.WriteFixed32(AccountLevelInfoTag);
            }
            if (PrivacyInfoTag != 0)
            {
                output.WriteRawTag(29);
                output.WriteFixed32(PrivacyInfoTag);
            }
            if (ParentalControlInfoTag != 0)
            {
                output.WriteRawTag(37);
                output.WriteFixed32(ParentalControlInfoTag);
            }
            gameLevelInfoTags_.WriteTo(output, _repeated_gameLevelInfoTags_codec);
            gameStatusTags_.WriteTo(output, _repeated_gameStatusTags_codec);
            gameAccountTags_.WriteTo(output, _repeated_gameAccountTags_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            if (AccountLevelInfoTag != 0)
            {
                size += 1 + 4;
            }
            if (PrivacyInfoTag != 0)
            {
                size += 1 + 4;
            }
            if (ParentalControlInfoTag != 0)
            {
                size += 1 + 4;
            }
            size += gameLevelInfoTags_.CalculateSize(_repeated_gameLevelInfoTags_codec);
            size += gameStatusTags_.CalculateSize(_repeated_gameStatusTags_codec);
            size += gameAccountTags_.CalculateSize(_repeated_gameAccountTags_codec);
            return size;
        }

        public void MergeFrom(AccountFieldTags other)
        {
            if (other == null)
            {
                return;
            }
            if (other.AccountLevelInfoTag != 0)
            {
                AccountLevelInfoTag = other.AccountLevelInfoTag;
            }
            if (other.PrivacyInfoTag != 0)
            {
                PrivacyInfoTag = other.PrivacyInfoTag;
            }
            if (other.ParentalControlInfoTag != 0)
            {
                ParentalControlInfoTag = other.ParentalControlInfoTag;
            }
            gameLevelInfoTags_.Add(other.gameLevelInfoTags_);
            gameStatusTags_.Add(other.gameStatusTags_);
            gameAccountTags_.Add(other.gameAccountTags_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 21:
                        {
                            AccountLevelInfoTag = input.ReadFixed32();
                            break;
                        }
                    case 29:
                        {
                            PrivacyInfoTag = input.ReadFixed32();
                            break;
                        }
                    case 37:
                        {
                            ParentalControlInfoTag = input.ReadFixed32();
                            break;
                        }
                    case 58:
                        {
                            gameLevelInfoTags_.AddEntriesFrom(input, _repeated_gameLevelInfoTags_codec);
                            break;
                        }
                    case 74:
                        {
                            gameStatusTags_.AddEntriesFrom(input, _repeated_gameStatusTags_codec);
                            break;
                        }
                    case 90:
                        {
                            gameAccountTags_.AddEntriesFrom(input, _repeated_gameAccountTags_codec);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountFieldTags : pb::IMessage<GameAccountFieldTags>
    {
        private static readonly pb::MessageParser<GameAccountFieldTags> _parser = new pb::MessageParser<GameAccountFieldTags>(() => new GameAccountFieldTags());
        public static pb::MessageParser<GameAccountFieldTags> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[14]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountFieldTags()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountFieldTags(GameAccountFieldTags other) : this()
        {
            gameLevelInfoTag_ = other.gameLevelInfoTag_;
            gameTimeInfoTag_ = other.gameTimeInfoTag_;
            gameStatusTag_ = other.gameStatusTag_;
            rafInfoTag_ = other.rafInfoTag_;
        }

        public GameAccountFieldTags Clone()
        {
            return new GameAccountFieldTags(this);
        }

        /// <summary>Field number for the "game_level_info_tag" field.</summary>
        public const int GameLevelInfoTagFieldNumber = 2;
        private uint gameLevelInfoTag_;
        public uint GameLevelInfoTag
        {
            get { return gameLevelInfoTag_; }
            set
            {
                gameLevelInfoTag_ = value;
            }
        }

        /// <summary>Field number for the "game_time_info_tag" field.</summary>
        public const int GameTimeInfoTagFieldNumber = 3;
        private uint gameTimeInfoTag_;
        public uint GameTimeInfoTag
        {
            get { return gameTimeInfoTag_; }
            set
            {
                gameTimeInfoTag_ = value;
            }
        }

        /// <summary>Field number for the "game_status_tag" field.</summary>
        public const int GameStatusTagFieldNumber = 4;
        private uint gameStatusTag_;
        public uint GameStatusTag
        {
            get { return gameStatusTag_; }
            set
            {
                gameStatusTag_ = value;
            }
        }

        /// <summary>Field number for the "raf_info_tag" field.</summary>
        public const int RafInfoTagFieldNumber = 5;
        private uint rafInfoTag_;
        public uint RafInfoTag
        {
            get { return rafInfoTag_; }
            set
            {
                rafInfoTag_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountFieldTags);
        }

        public bool Equals(GameAccountFieldTags other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (GameLevelInfoTag != other.GameLevelInfoTag) return false;
            if (GameTimeInfoTag != other.GameTimeInfoTag) return false;
            if (GameStatusTag != other.GameStatusTag) return false;
            if (RafInfoTag != other.RafInfoTag) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (GameLevelInfoTag != 0) hash ^= GameLevelInfoTag.GetHashCode();
            if (GameTimeInfoTag != 0) hash ^= GameTimeInfoTag.GetHashCode();
            if (GameStatusTag != 0) hash ^= GameStatusTag.GetHashCode();
            if (RafInfoTag != 0) hash ^= RafInfoTag.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (GameLevelInfoTag != 0)
            {
                output.WriteRawTag(21);
                output.WriteFixed32(GameLevelInfoTag);
            }
            if (GameTimeInfoTag != 0)
            {
                output.WriteRawTag(29);
                output.WriteFixed32(GameTimeInfoTag);
            }
            if (GameStatusTag != 0)
            {
                output.WriteRawTag(37);
                output.WriteFixed32(GameStatusTag);
            }
            if (RafInfoTag != 0)
            {
                output.WriteRawTag(45);
                output.WriteFixed32(RafInfoTag);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (GameLevelInfoTag != 0)
            {
                size += 1 + 4;
            }
            if (GameTimeInfoTag != 0)
            {
                size += 1 + 4;
            }
            if (GameStatusTag != 0)
            {
                size += 1 + 4;
            }
            if (RafInfoTag != 0)
            {
                size += 1 + 4;
            }
            return size;
        }

        public void MergeFrom(GameAccountFieldTags other)
        {
            if (other == null)
            {
                return;
            }
            if (other.GameLevelInfoTag != 0)
            {
                GameLevelInfoTag = other.GameLevelInfoTag;
            }
            if (other.GameTimeInfoTag != 0)
            {
                GameTimeInfoTag = other.GameTimeInfoTag;
            }
            if (other.GameStatusTag != 0)
            {
                GameStatusTag = other.GameStatusTag;
            }
            if (other.RafInfoTag != 0)
            {
                RafInfoTag = other.RafInfoTag;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 21:
                        {
                            GameLevelInfoTag = input.ReadFixed32();
                            break;
                        }
                    case 29:
                        {
                            GameTimeInfoTag = input.ReadFixed32();
                            break;
                        }
                    case 37:
                        {
                            GameStatusTag = input.ReadFixed32();
                            break;
                        }
                    case 45:
                        {
                            RafInfoTag = input.ReadFixed32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountFieldOptions : pb::IMessage<AccountFieldOptions>
    {
        private static readonly pb::MessageParser<AccountFieldOptions> _parser = new pb::MessageParser<AccountFieldOptions>(() => new AccountFieldOptions());
        public static pb::MessageParser<AccountFieldOptions> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[15]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountFieldOptions()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountFieldOptions(AccountFieldOptions other) : this()
        {
            allFields_ = other.allFields_;
            fieldAccountLevelInfo_ = other.fieldAccountLevelInfo_;
            fieldPrivacyInfo_ = other.fieldPrivacyInfo_;
            fieldParentalControlInfo_ = other.fieldParentalControlInfo_;
            fieldGameLevelInfo_ = other.fieldGameLevelInfo_;
            fieldGameStatus_ = other.fieldGameStatus_;
            fieldGameAccounts_ = other.fieldGameAccounts_;
        }

        public AccountFieldOptions Clone()
        {
            return new AccountFieldOptions(this);
        }

        /// <summary>Field number for the "all_fields" field.</summary>
        public const int AllFieldsFieldNumber = 1;
        private bool allFields_;
        public bool AllFields
        {
            get { return allFields_; }
            set
            {
                allFields_ = value;
            }
        }

        /// <summary>Field number for the "field_account_level_info" field.</summary>
        public const int FieldAccountLevelInfoFieldNumber = 2;
        private bool fieldAccountLevelInfo_;
        public bool FieldAccountLevelInfo
        {
            get { return fieldAccountLevelInfo_; }
            set
            {
                fieldAccountLevelInfo_ = value;
            }
        }

        /// <summary>Field number for the "field_privacy_info" field.</summary>
        public const int FieldPrivacyInfoFieldNumber = 3;
        private bool fieldPrivacyInfo_;
        public bool FieldPrivacyInfo
        {
            get { return fieldPrivacyInfo_; }
            set
            {
                fieldPrivacyInfo_ = value;
            }
        }

        /// <summary>Field number for the "field_parental_control_info" field.</summary>
        public const int FieldParentalControlInfoFieldNumber = 4;
        private bool fieldParentalControlInfo_;
        public bool FieldParentalControlInfo
        {
            get { return fieldParentalControlInfo_; }
            set
            {
                fieldParentalControlInfo_ = value;
            }
        }

        /// <summary>Field number for the "field_game_level_info" field.</summary>
        public const int FieldGameLevelInfoFieldNumber = 6;
        private bool fieldGameLevelInfo_;
        public bool FieldGameLevelInfo
        {
            get { return fieldGameLevelInfo_; }
            set
            {
                fieldGameLevelInfo_ = value;
            }
        }

        /// <summary>Field number for the "field_game_status" field.</summary>
        public const int FieldGameStatusFieldNumber = 7;
        private bool fieldGameStatus_;
        public bool FieldGameStatus
        {
            get { return fieldGameStatus_; }
            set
            {
                fieldGameStatus_ = value;
            }
        }

        /// <summary>Field number for the "field_game_accounts" field.</summary>
        public const int FieldGameAccountsFieldNumber = 8;
        private bool fieldGameAccounts_;
        public bool FieldGameAccounts
        {
            get { return fieldGameAccounts_; }
            set
            {
                fieldGameAccounts_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountFieldOptions);
        }

        public bool Equals(AccountFieldOptions other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (AllFields != other.AllFields) return false;
            if (FieldAccountLevelInfo != other.FieldAccountLevelInfo) return false;
            if (FieldPrivacyInfo != other.FieldPrivacyInfo) return false;
            if (FieldParentalControlInfo != other.FieldParentalControlInfo) return false;
            if (FieldGameLevelInfo != other.FieldGameLevelInfo) return false;
            if (FieldGameStatus != other.FieldGameStatus) return false;
            if (FieldGameAccounts != other.FieldGameAccounts) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (AllFields != false) hash ^= AllFields.GetHashCode();
            if (FieldAccountLevelInfo != false) hash ^= FieldAccountLevelInfo.GetHashCode();
            if (FieldPrivacyInfo != false) hash ^= FieldPrivacyInfo.GetHashCode();
            if (FieldParentalControlInfo != false) hash ^= FieldParentalControlInfo.GetHashCode();
            if (FieldGameLevelInfo != false) hash ^= FieldGameLevelInfo.GetHashCode();
            if (FieldGameStatus != false) hash ^= FieldGameStatus.GetHashCode();
            if (FieldGameAccounts != false) hash ^= FieldGameAccounts.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (AllFields != false)
            {
                output.WriteRawTag(8);
                output.WriteBool(AllFields);
            }
            if (FieldAccountLevelInfo != false)
            {
                output.WriteRawTag(16);
                output.WriteBool(FieldAccountLevelInfo);
            }
            if (FieldPrivacyInfo != false)
            {
                output.WriteRawTag(24);
                output.WriteBool(FieldPrivacyInfo);
            }
            if (FieldParentalControlInfo != false)
            {
                output.WriteRawTag(32);
                output.WriteBool(FieldParentalControlInfo);
            }
            if (FieldGameLevelInfo != false)
            {
                output.WriteRawTag(48);
                output.WriteBool(FieldGameLevelInfo);
            }
            if (FieldGameStatus != false)
            {
                output.WriteRawTag(56);
                output.WriteBool(FieldGameStatus);
            }
            if (FieldGameAccounts != false)
            {
                output.WriteRawTag(64);
                output.WriteBool(FieldGameAccounts);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (AllFields != false)
            {
                size += 1 + 1;
            }
            if (FieldAccountLevelInfo != false)
            {
                size += 1 + 1;
            }
            if (FieldPrivacyInfo != false)
            {
                size += 1 + 1;
            }
            if (FieldParentalControlInfo != false)
            {
                size += 1 + 1;
            }
            if (FieldGameLevelInfo != false)
            {
                size += 1 + 1;
            }
            if (FieldGameStatus != false)
            {
                size += 1 + 1;
            }
            if (FieldGameAccounts != false)
            {
                size += 1 + 1;
            }
            return size;
        }

        public void MergeFrom(AccountFieldOptions other)
        {
            if (other == null)
            {
                return;
            }
            if (other.AllFields != false)
            {
                AllFields = other.AllFields;
            }
            if (other.FieldAccountLevelInfo != false)
            {
                FieldAccountLevelInfo = other.FieldAccountLevelInfo;
            }
            if (other.FieldPrivacyInfo != false)
            {
                FieldPrivacyInfo = other.FieldPrivacyInfo;
            }
            if (other.FieldParentalControlInfo != false)
            {
                FieldParentalControlInfo = other.FieldParentalControlInfo;
            }
            if (other.FieldGameLevelInfo != false)
            {
                FieldGameLevelInfo = other.FieldGameLevelInfo;
            }
            if (other.FieldGameStatus != false)
            {
                FieldGameStatus = other.FieldGameStatus;
            }
            if (other.FieldGameAccounts != false)
            {
                FieldGameAccounts = other.FieldGameAccounts;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            AllFields = input.ReadBool();
                            break;
                        }
                    case 16:
                        {
                            FieldAccountLevelInfo = input.ReadBool();
                            break;
                        }
                    case 24:
                        {
                            FieldPrivacyInfo = input.ReadBool();
                            break;
                        }
                    case 32:
                        {
                            FieldParentalControlInfo = input.ReadBool();
                            break;
                        }
                    case 48:
                        {
                            FieldGameLevelInfo = input.ReadBool();
                            break;
                        }
                    case 56:
                        {
                            FieldGameStatus = input.ReadBool();
                            break;
                        }
                    case 64:
                        {
                            FieldGameAccounts = input.ReadBool();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountFieldOptions : pb::IMessage<GameAccountFieldOptions>
    {
        private static readonly pb::MessageParser<GameAccountFieldOptions> _parser = new pb::MessageParser<GameAccountFieldOptions>(() => new GameAccountFieldOptions());
        public static pb::MessageParser<GameAccountFieldOptions> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[16]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountFieldOptions()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountFieldOptions(GameAccountFieldOptions other) : this()
        {
            allFields_ = other.allFields_;
            fieldGameLevelInfo_ = other.fieldGameLevelInfo_;
            fieldGameTimeInfo_ = other.fieldGameTimeInfo_;
            fieldGameStatus_ = other.fieldGameStatus_;
            fieldRafInfo_ = other.fieldRafInfo_;
        }

        public GameAccountFieldOptions Clone()
        {
            return new GameAccountFieldOptions(this);
        }

        /// <summary>Field number for the "all_fields" field.</summary>
        public const int AllFieldsFieldNumber = 1;
        private bool allFields_;
        public bool AllFields
        {
            get { return allFields_; }
            set
            {
                allFields_ = value;
            }
        }

        /// <summary>Field number for the "field_game_level_info" field.</summary>
        public const int FieldGameLevelInfoFieldNumber = 2;
        private bool fieldGameLevelInfo_;
        public bool FieldGameLevelInfo
        {
            get { return fieldGameLevelInfo_; }
            set
            {
                fieldGameLevelInfo_ = value;
            }
        }

        /// <summary>Field number for the "field_game_time_info" field.</summary>
        public const int FieldGameTimeInfoFieldNumber = 3;
        private bool fieldGameTimeInfo_;
        public bool FieldGameTimeInfo
        {
            get { return fieldGameTimeInfo_; }
            set
            {
                fieldGameTimeInfo_ = value;
            }
        }

        /// <summary>Field number for the "field_game_status" field.</summary>
        public const int FieldGameStatusFieldNumber = 4;
        private bool fieldGameStatus_;
        public bool FieldGameStatus
        {
            get { return fieldGameStatus_; }
            set
            {
                fieldGameStatus_ = value;
            }
        }

        /// <summary>Field number for the "field_raf_info" field.</summary>
        public const int FieldRafInfoFieldNumber = 5;
        private bool fieldRafInfo_;
        public bool FieldRafInfo
        {
            get { return fieldRafInfo_; }
            set
            {
                fieldRafInfo_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountFieldOptions);
        }

        public bool Equals(GameAccountFieldOptions other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (AllFields != other.AllFields) return false;
            if (FieldGameLevelInfo != other.FieldGameLevelInfo) return false;
            if (FieldGameTimeInfo != other.FieldGameTimeInfo) return false;
            if (FieldGameStatus != other.FieldGameStatus) return false;
            if (FieldRafInfo != other.FieldRafInfo) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (AllFields != false) hash ^= AllFields.GetHashCode();
            if (FieldGameLevelInfo != false) hash ^= FieldGameLevelInfo.GetHashCode();
            if (FieldGameTimeInfo != false) hash ^= FieldGameTimeInfo.GetHashCode();
            if (FieldGameStatus != false) hash ^= FieldGameStatus.GetHashCode();
            if (FieldRafInfo != false) hash ^= FieldRafInfo.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (AllFields != false)
            {
                output.WriteRawTag(8);
                output.WriteBool(AllFields);
            }
            if (FieldGameLevelInfo != false)
            {
                output.WriteRawTag(16);
                output.WriteBool(FieldGameLevelInfo);
            }
            if (FieldGameTimeInfo != false)
            {
                output.WriteRawTag(24);
                output.WriteBool(FieldGameTimeInfo);
            }
            if (FieldGameStatus != false)
            {
                output.WriteRawTag(32);
                output.WriteBool(FieldGameStatus);
            }
            if (FieldRafInfo != false)
            {
                output.WriteRawTag(40);
                output.WriteBool(FieldRafInfo);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (AllFields != false)
            {
                size += 1 + 1;
            }
            if (FieldGameLevelInfo != false)
            {
                size += 1 + 1;
            }
            if (FieldGameTimeInfo != false)
            {
                size += 1 + 1;
            }
            if (FieldGameStatus != false)
            {
                size += 1 + 1;
            }
            if (FieldRafInfo != false)
            {
                size += 1 + 1;
            }
            return size;
        }

        public void MergeFrom(GameAccountFieldOptions other)
        {
            if (other == null)
            {
                return;
            }
            if (other.AllFields != false)
            {
                AllFields = other.AllFields;
            }
            if (other.FieldGameLevelInfo != false)
            {
                FieldGameLevelInfo = other.FieldGameLevelInfo;
            }
            if (other.FieldGameTimeInfo != false)
            {
                FieldGameTimeInfo = other.FieldGameTimeInfo;
            }
            if (other.FieldGameStatus != false)
            {
                FieldGameStatus = other.FieldGameStatus;
            }
            if (other.FieldRafInfo != false)
            {
                FieldRafInfo = other.FieldRafInfo;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            AllFields = input.ReadBool();
                            break;
                        }
                    case 16:
                        {
                            FieldGameLevelInfo = input.ReadBool();
                            break;
                        }
                    case 24:
                        {
                            FieldGameTimeInfo = input.ReadBool();
                            break;
                        }
                    case 32:
                        {
                            FieldGameStatus = input.ReadBool();
                            break;
                        }
                    case 40:
                        {
                            FieldRafInfo = input.ReadBool();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class SubscriberReference : pb::IMessage<SubscriberReference>
    {
        private static readonly pb::MessageParser<SubscriberReference> _parser = new pb::MessageParser<SubscriberReference>(() => new SubscriberReference());
        public static pb::MessageParser<SubscriberReference> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[17]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public SubscriberReference()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public SubscriberReference(SubscriberReference other) : this()
        {
            objectId_ = other.objectId_;
            EntityId = other.entityId_ != null ? other.EntityId.Clone() : null;
            AccountOptions = other.accountOptions_ != null ? other.AccountOptions.Clone() : null;
            AccountTags = other.accountTags_ != null ? other.AccountTags.Clone() : null;
            GameAccountOptions = other.gameAccountOptions_ != null ? other.GameAccountOptions.Clone() : null;
            GameAccountTags = other.gameAccountTags_ != null ? other.GameAccountTags.Clone() : null;
            subscriberId_ = other.subscriberId_;
        }

        public SubscriberReference Clone()
        {
            return new SubscriberReference(this);
        }

        /// <summary>Field number for the "object_id" field.</summary>
        public const int ObjectIdFieldNumber = 1;
        private ulong objectId_;
        public ulong ObjectId
        {
            get { return objectId_; }
            set
            {
                objectId_ = value;
            }
        }

        /// <summary>Field number for the "entity_id" field.</summary>
        public const int EntityIdFieldNumber = 2;
        private Bgs.Protocol.EntityId entityId_;
        public Bgs.Protocol.EntityId EntityId
        {
            get { return entityId_; }
            set
            {
                entityId_ = value;
            }
        }

        /// <summary>Field number for the "account_options" field.</summary>
        public const int AccountOptionsFieldNumber = 3;
        private Bgs.Protocol.Account.V1.AccountFieldOptions accountOptions_;
        public Bgs.Protocol.Account.V1.AccountFieldOptions AccountOptions
        {
            get { return accountOptions_; }
            set
            {
                accountOptions_ = value;
            }
        }

        /// <summary>Field number for the "account_tags" field.</summary>
        public const int AccountTagsFieldNumber = 4;
        private Bgs.Protocol.Account.V1.AccountFieldTags accountTags_;
        public Bgs.Protocol.Account.V1.AccountFieldTags AccountTags
        {
            get { return accountTags_; }
            set
            {
                accountTags_ = value;
            }
        }

        /// <summary>Field number for the "game_account_options" field.</summary>
        public const int GameAccountOptionsFieldNumber = 5;
        private Bgs.Protocol.Account.V1.GameAccountFieldOptions gameAccountOptions_;
        public Bgs.Protocol.Account.V1.GameAccountFieldOptions GameAccountOptions
        {
            get { return gameAccountOptions_; }
            set
            {
                gameAccountOptions_ = value;
            }
        }

        /// <summary>Field number for the "game_account_tags" field.</summary>
        public const int GameAccountTagsFieldNumber = 6;
        private Bgs.Protocol.Account.V1.GameAccountFieldTags gameAccountTags_;
        public Bgs.Protocol.Account.V1.GameAccountFieldTags GameAccountTags
        {
            get { return gameAccountTags_; }
            set
            {
                gameAccountTags_ = value;
            }
        }

        /// <summary>Field number for the "subscriber_id" field.</summary>
        public const int SubscriberIdFieldNumber = 7;
        private ulong subscriberId_;
        public ulong SubscriberId
        {
            get { return subscriberId_; }
            set
            {
                subscriberId_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as SubscriberReference);
        }

        public bool Equals(SubscriberReference other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (ObjectId != other.ObjectId) return false;
            if (!object.Equals(EntityId, other.EntityId)) return false;
            if (!object.Equals(AccountOptions, other.AccountOptions)) return false;
            if (!object.Equals(AccountTags, other.AccountTags)) return false;
            if (!object.Equals(GameAccountOptions, other.GameAccountOptions)) return false;
            if (!object.Equals(GameAccountTags, other.GameAccountTags)) return false;
            if (SubscriberId != other.SubscriberId) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (ObjectId != 0UL) hash ^= ObjectId.GetHashCode();
            if (entityId_ != null) hash ^= EntityId.GetHashCode();
            if (accountOptions_ != null) hash ^= AccountOptions.GetHashCode();
            if (accountTags_ != null) hash ^= AccountTags.GetHashCode();
            if (gameAccountOptions_ != null) hash ^= GameAccountOptions.GetHashCode();
            if (gameAccountTags_ != null) hash ^= GameAccountTags.GetHashCode();
            if (SubscriberId != 0UL) hash ^= SubscriberId.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (ObjectId != 0UL)
            {
                output.WriteRawTag(8);
                output.WriteUInt64(ObjectId);
            }
            if (entityId_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(EntityId);
            }
            if (accountOptions_ != null)
            {
                output.WriteRawTag(26);
                output.WriteMessage(AccountOptions);
            }
            if (accountTags_ != null)
            {
                output.WriteRawTag(34);
                output.WriteMessage(AccountTags);
            }
            if (gameAccountOptions_ != null)
            {
                output.WriteRawTag(42);
                output.WriteMessage(GameAccountOptions);
            }
            if (gameAccountTags_ != null)
            {
                output.WriteRawTag(50);
                output.WriteMessage(GameAccountTags);
            }
            if (SubscriberId != 0UL)
            {
                output.WriteRawTag(56);
                output.WriteUInt64(SubscriberId);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (ObjectId != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ObjectId);
            }
            if (entityId_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(EntityId);
            }
            if (accountOptions_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(AccountOptions);
            }
            if (accountTags_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(AccountTags);
            }
            if (gameAccountOptions_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccountOptions);
            }
            if (gameAccountTags_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccountTags);
            }
            if (SubscriberId != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(SubscriberId);
            }
            return size;
        }

        public void MergeFrom(SubscriberReference other)
        {
            if (other == null)
            {
                return;
            }
            if (other.ObjectId != 0UL)
            {
                ObjectId = other.ObjectId;
            }
            if (other.entityId_ != null)
            {
                if (entityId_ == null)
                {
                    entityId_ = new Bgs.Protocol.EntityId();
                }
                EntityId.MergeFrom(other.EntityId);
            }
            if (other.accountOptions_ != null)
            {
                if (accountOptions_ == null)
                {
                    accountOptions_ = new Bgs.Protocol.Account.V1.AccountFieldOptions();
                }
                AccountOptions.MergeFrom(other.AccountOptions);
            }
            if (other.accountTags_ != null)
            {
                if (accountTags_ == null)
                {
                    accountTags_ = new Bgs.Protocol.Account.V1.AccountFieldTags();
                }
                AccountTags.MergeFrom(other.AccountTags);
            }
            if (other.gameAccountOptions_ != null)
            {
                if (gameAccountOptions_ == null)
                {
                    gameAccountOptions_ = new Bgs.Protocol.Account.V1.GameAccountFieldOptions();
                }
                GameAccountOptions.MergeFrom(other.GameAccountOptions);
            }
            if (other.gameAccountTags_ != null)
            {
                if (gameAccountTags_ == null)
                {
                    gameAccountTags_ = new Bgs.Protocol.Account.V1.GameAccountFieldTags();
                }
                GameAccountTags.MergeFrom(other.GameAccountTags);
            }
            if (other.SubscriberId != 0UL)
            {
                SubscriberId = other.SubscriberId;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            ObjectId = input.ReadUInt64();
                            break;
                        }
                    case 18:
                        {
                            if (entityId_ == null)
                            {
                                entityId_ = new Bgs.Protocol.EntityId();
                            }
                            input.ReadMessage(entityId_);
                            break;
                        }
                    case 26:
                        {
                            if (accountOptions_ == null)
                            {
                                accountOptions_ = new Bgs.Protocol.Account.V1.AccountFieldOptions();
                            }
                            input.ReadMessage(accountOptions_);
                            break;
                        }
                    case 34:
                        {
                            if (accountTags_ == null)
                            {
                                accountTags_ = new Bgs.Protocol.Account.V1.AccountFieldTags();
                            }
                            input.ReadMessage(accountTags_);
                            break;
                        }
                    case 42:
                        {
                            if (gameAccountOptions_ == null)
                            {
                                gameAccountOptions_ = new Bgs.Protocol.Account.V1.GameAccountFieldOptions();
                            }
                            input.ReadMessage(gameAccountOptions_);
                            break;
                        }
                    case 50:
                        {
                            if (gameAccountTags_ == null)
                            {
                                gameAccountTags_ = new Bgs.Protocol.Account.V1.GameAccountFieldTags();
                            }
                            input.ReadMessage(gameAccountTags_);
                            break;
                        }
                    case 56:
                        {
                            SubscriberId = input.ReadUInt64();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountLevelInfo : pb::IMessage<AccountLevelInfo>
    {
        private static readonly pb::MessageParser<AccountLevelInfo> _parser = new pb::MessageParser<AccountLevelInfo>(() => new AccountLevelInfo());
        public static pb::MessageParser<AccountLevelInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[18]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountLevelInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountLevelInfo(AccountLevelInfo other) : this()
        {
            licenses_ = other.licenses_.Clone();
            defaultCurrency_ = other.defaultCurrency_;
            country_ = other.country_;
            preferredRegion_ = other.preferredRegion_;
            fullName_ = other.fullName_;
            battleTag_ = other.battleTag_;
            muted_ = other.muted_;
            manualReview_ = other.manualReview_;
            accountPaidAny_ = other.accountPaidAny_;
            identityCheckStatus_ = other.identityCheckStatus_;
            email_ = other.email_;
        }

        public AccountLevelInfo Clone()
        {
            return new AccountLevelInfo(this);
        }

        /// <summary>Field number for the "licenses" field.</summary>
        public const int LicensesFieldNumber = 3;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.AccountLicense> _repeated_licenses_codec
            = pb::FieldCodec.ForMessage(26, Bgs.Protocol.Account.V1.AccountLicense.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> licenses_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> Licenses
        {
            get { return licenses_; }
        }

        /// <summary>Field number for the "default_currency" field.</summary>
        public const int DefaultCurrencyFieldNumber = 4;
        private uint defaultCurrency_;
        public uint DefaultCurrency
        {
            get { return defaultCurrency_; }
            set
            {
                defaultCurrency_ = value;
            }
        }

        /// <summary>Field number for the "country" field.</summary>
        public const int CountryFieldNumber = 5;
        private string country_ = "";
        public string Country
        {
            get { return country_; }
            set
            {
                country_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "preferred_region" field.</summary>
        public const int PreferredRegionFieldNumber = 6;
        private uint preferredRegion_;
        public uint PreferredRegion
        {
            get { return preferredRegion_; }
            set
            {
                preferredRegion_ = value;
            }
        }

        /// <summary>Field number for the "full_name" field.</summary>
        public const int FullNameFieldNumber = 7;
        private string fullName_ = "";
        public string FullName
        {
            get { return fullName_; }
            set
            {
                fullName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "battle_tag" field.</summary>
        public const int BattleTagFieldNumber = 8;
        private string battleTag_ = "";
        public string BattleTag
        {
            get { return battleTag_; }
            set
            {
                battleTag_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "muted" field.</summary>
        public const int MutedFieldNumber = 9;
        private bool muted_;
        public bool Muted
        {
            get { return muted_; }
            set
            {
                muted_ = value;
            }
        }

        /// <summary>Field number for the "manual_review" field.</summary>
        public const int ManualReviewFieldNumber = 10;
        private bool manualReview_;
        public bool ManualReview
        {
            get { return manualReview_; }
            set
            {
                manualReview_ = value;
            }
        }

        /// <summary>Field number for the "account_paid_any" field.</summary>
        public const int AccountPaidAnyFieldNumber = 11;
        private bool accountPaidAny_;
        public bool AccountPaidAny
        {
            get { return accountPaidAny_; }
            set
            {
                accountPaidAny_ = value;
            }
        }

        /// <summary>Field number for the "identity_check_status" field.</summary>
        public const int IdentityCheckStatusFieldNumber = 12;
        private Bgs.Protocol.Account.V1.IdentityVerificationStatus identityCheckStatus_ = Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA;
        public Bgs.Protocol.Account.V1.IdentityVerificationStatus IdentityCheckStatus
        {
            get { return identityCheckStatus_; }
            set
            {
                identityCheckStatus_ = value;
            }
        }

        /// <summary>Field number for the "email" field.</summary>
        public const int EmailFieldNumber = 13;
        private string email_ = "";
        public string Email
        {
            get { return email_; }
            set
            {
                email_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountLevelInfo);
        }

        public bool Equals(AccountLevelInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!licenses_.Equals(other.licenses_)) return false;
            if (DefaultCurrency != other.DefaultCurrency) return false;
            if (Country != other.Country) return false;
            if (PreferredRegion != other.PreferredRegion) return false;
            if (FullName != other.FullName) return false;
            if (BattleTag != other.BattleTag) return false;
            if (Muted != other.Muted) return false;
            if (ManualReview != other.ManualReview) return false;
            if (AccountPaidAny != other.AccountPaidAny) return false;
            if (IdentityCheckStatus != other.IdentityCheckStatus) return false;
            if (Email != other.Email) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            hash ^= licenses_.GetHashCode();
            if (DefaultCurrency != 0) hash ^= DefaultCurrency.GetHashCode();
            if (Country.Length != 0) hash ^= Country.GetHashCode();
            if (PreferredRegion != 0) hash ^= PreferredRegion.GetHashCode();
            if (FullName.Length != 0) hash ^= FullName.GetHashCode();
            if (BattleTag.Length != 0) hash ^= BattleTag.GetHashCode();
            if (Muted != false) hash ^= Muted.GetHashCode();
            if (ManualReview != false) hash ^= ManualReview.GetHashCode();
            if (AccountPaidAny != false) hash ^= AccountPaidAny.GetHashCode();
            if (IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA) hash ^= IdentityCheckStatus.GetHashCode();
            if (Email.Length != 0) hash ^= Email.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            licenses_.WriteTo(output, _repeated_licenses_codec);
            if (DefaultCurrency != 0)
            {
                output.WriteRawTag(37);
                output.WriteFixed32(DefaultCurrency);
            }
            if (Country.Length != 0)
            {
                output.WriteRawTag(42);
                output.WriteString(Country);
            }
            if (PreferredRegion != 0)
            {
                output.WriteRawTag(48);
                output.WriteUInt32(PreferredRegion);
            }
            if (FullName.Length != 0)
            {
                output.WriteRawTag(58);
                output.WriteString(FullName);
            }
            if (BattleTag.Length != 0)
            {
                output.WriteRawTag(66);
                output.WriteString(BattleTag);
            }
            if (Muted != false)
            {
                output.WriteRawTag(72);
                output.WriteBool(Muted);
            }
            if (ManualReview != false)
            {
                output.WriteRawTag(80);
                output.WriteBool(ManualReview);
            }
            if (AccountPaidAny != false)
            {
                output.WriteRawTag(88);
                output.WriteBool(AccountPaidAny);
            }
            if (IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA)
            {
                output.WriteRawTag(96);
                output.WriteEnum((int)IdentityCheckStatus);
            }
            if (Email.Length != 0)
            {
                output.WriteRawTag(106);
                output.WriteString(Email);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            size += licenses_.CalculateSize(_repeated_licenses_codec);
            if (DefaultCurrency != 0)
            {
                size += 1 + 4;
            }
            if (Country.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Country);
            }
            if (PreferredRegion != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(PreferredRegion);
            }
            if (FullName.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(FullName);
            }
            if (BattleTag.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(BattleTag);
            }
            if (Muted != false)
            {
                size += 1 + 1;
            }
            if (ManualReview != false)
            {
                size += 1 + 1;
            }
            if (AccountPaidAny != false)
            {
                size += 1 + 1;
            }
            if (IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA)
            {
                size += 1 + pb::CodedOutputStream.ComputeEnumSize((int)IdentityCheckStatus);
            }
            if (Email.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Email);
            }
            return size;
        }

        public void MergeFrom(AccountLevelInfo other)
        {
            if (other == null)
            {
                return;
            }
            licenses_.Add(other.licenses_);
            if (other.DefaultCurrency != 0)
            {
                DefaultCurrency = other.DefaultCurrency;
            }
            if (other.Country.Length != 0)
            {
                Country = other.Country;
            }
            if (other.PreferredRegion != 0)
            {
                PreferredRegion = other.PreferredRegion;
            }
            if (other.FullName.Length != 0)
            {
                FullName = other.FullName;
            }
            if (other.BattleTag.Length != 0)
            {
                BattleTag = other.BattleTag;
            }
            if (other.Muted != false)
            {
                Muted = other.Muted;
            }
            if (other.ManualReview != false)
            {
                ManualReview = other.ManualReview;
            }
            if (other.AccountPaidAny != false)
            {
                AccountPaidAny = other.AccountPaidAny;
            }
            if (other.IdentityCheckStatus != Bgs.Protocol.Account.V1.IdentityVerificationStatus.IDENT_NO_DATA)
            {
                IdentityCheckStatus = other.IdentityCheckStatus;
            }
            if (other.Email.Length != 0)
            {
                Email = other.Email;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 26:
                        {
                            licenses_.AddEntriesFrom(input, _repeated_licenses_codec);
                            break;
                        }
                    case 37:
                        {
                            DefaultCurrency = input.ReadFixed32();
                            break;
                        }
                    case 42:
                        {
                            Country = input.ReadString();
                            break;
                        }
                    case 48:
                        {
                            PreferredRegion = input.ReadUInt32();
                            break;
                        }
                    case 58:
                        {
                            FullName = input.ReadString();
                            break;
                        }
                    case 66:
                        {
                            BattleTag = input.ReadString();
                            break;
                        }
                    case 72:
                        {
                            Muted = input.ReadBool();
                            break;
                        }
                    case 80:
                        {
                            ManualReview = input.ReadBool();
                            break;
                        }
                    case 88:
                        {
                            AccountPaidAny = input.ReadBool();
                            break;
                        }
                    case 96:
                        {
                            identityCheckStatus_ = (Bgs.Protocol.Account.V1.IdentityVerificationStatus)input.ReadEnum();
                            break;
                        }
                    case 106:
                        {
                            Email = input.ReadString();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class PrivacyInfo : pb::IMessage<PrivacyInfo>
    {
        private static readonly pb::MessageParser<PrivacyInfo> _parser = new pb::MessageParser<PrivacyInfo>(() => new PrivacyInfo());
        public static pb::MessageParser<PrivacyInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[19]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public PrivacyInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public PrivacyInfo(PrivacyInfo other) : this()
        {
            isUsingRid_ = other.isUsingRid_;
            isRealIdVisibleForViewFriends_ = other.isRealIdVisibleForViewFriends_;
            isHiddenFromFriendFinder_ = other.isHiddenFromFriendFinder_;
            gameInfoPrivacy_ = other.gameInfoPrivacy_;
        }

        public PrivacyInfo Clone()
        {
            return new PrivacyInfo(this);
        }

        /// <summary>Field number for the "is_using_rid" field.</summary>
        public const int IsUsingRidFieldNumber = 3;
        private bool isUsingRid_;
        public bool IsUsingRid
        {
            get { return isUsingRid_; }
            set
            {
                bitArray.Set(IsUsingRidFieldNumber, true);
                isUsingRid_ = value;
            }
        }

        /// <summary>Field number for the "is_real_id_visible_for_view_friends" field.</summary>
        public const int IsRealIdVisibleForViewFriendsFieldNumber = 4;
        private bool isRealIdVisibleForViewFriends_;
        public bool IsRealIdVisibleForViewFriends
        {
            get { return isRealIdVisibleForViewFriends_; }
            set
            {
                bitArray.Set(IsRealIdVisibleForViewFriendsFieldNumber, true);
                isRealIdVisibleForViewFriends_ = value;
            }
        }

        /// <summary>Field number for the "is_hidden_from_friend_finder" field.</summary>
        public const int IsHiddenFromFriendFinderFieldNumber = 5;
        private bool isHiddenFromFriendFinder_;
        public bool IsHiddenFromFriendFinder
        {
            get { return isHiddenFromFriendFinder_; }
            set
            {
                bitArray.Set(IsHiddenFromFriendFinderFieldNumber, true);
                isHiddenFromFriendFinder_ = value;
            }
        }

        /// <summary>Field number for the "game_info_privacy" field.</summary>
        public const int GameInfoPrivacyFieldNumber = 6;
        private Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy gameInfoPrivacy_ = Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy.PRIVACY_ME;
        public Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy GameInfoPrivacy
        {
            get { return gameInfoPrivacy_; }
            set
            {
                bitArray.Set(GameInfoPrivacyFieldNumber, true);
                gameInfoPrivacy_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as PrivacyInfo);
        }

        public bool Equals(PrivacyInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (IsUsingRid != other.IsUsingRid) return false;
            if (IsRealIdVisibleForViewFriends != other.IsRealIdVisibleForViewFriends) return false;
            if (IsHiddenFromFriendFinder != other.IsHiddenFromFriendFinder) return false;
            if (GameInfoPrivacy != other.GameInfoPrivacy) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (IsUsingRid != false) hash ^= IsUsingRid.GetHashCode();
            if (IsRealIdVisibleForViewFriends != false) hash ^= IsRealIdVisibleForViewFriends.GetHashCode();
            if (IsHiddenFromFriendFinder != false) hash ^= IsHiddenFromFriendFinder.GetHashCode();
            if (GameInfoPrivacy != Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy.PRIVACY_ME) hash ^= GameInfoPrivacy.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (bitArray.Get(IsUsingRidFieldNumber))
            {
                output.WriteRawTag(24);
                output.WriteBool(IsUsingRid);
            }
            if (bitArray.Get(IsRealIdVisibleForViewFriendsFieldNumber))
            {
                output.WriteRawTag(32);
                output.WriteBool(IsRealIdVisibleForViewFriends);
            }
            if (bitArray.Get(IsHiddenFromFriendFinderFieldNumber))
            {
                output.WriteRawTag(40);
                output.WriteBool(IsHiddenFromFriendFinder);
            }
            if (bitArray.Get(GameInfoPrivacyFieldNumber))
            {
                output.WriteRawTag(48);
                output.WriteEnum((int)GameInfoPrivacy);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (bitArray.Get(IsUsingRidFieldNumber))
            {
                size += 1 + 1;
            }
            if (bitArray.Get(IsRealIdVisibleForViewFriendsFieldNumber))
            {
                size += 1 + 1;
            }
            if (bitArray.Get(IsHiddenFromFriendFinderFieldNumber))
            {
                size += 1 + 1;
            }
            if (bitArray.Get(GameInfoPrivacyFieldNumber))
            {
                size += 1 + pb::CodedOutputStream.ComputeEnumSize((int)GameInfoPrivacy);
            }
            return size;
        }

        public void MergeFrom(PrivacyInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.IsUsingRid != false)
            {
                IsUsingRid = other.IsUsingRid;
            }
            if (other.IsRealIdVisibleForViewFriends != false)
            {
                IsRealIdVisibleForViewFriends = other.IsRealIdVisibleForViewFriends;
            }
            if (other.IsHiddenFromFriendFinder != false)
            {
                IsHiddenFromFriendFinder = other.IsHiddenFromFriendFinder;
            }
            if (other.GameInfoPrivacy != Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy.PRIVACY_ME)
            {
                GameInfoPrivacy = other.GameInfoPrivacy;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 24:
                        {
                            IsUsingRid = input.ReadBool();
                            break;
                        }
                    case 32:
                        {
                            IsRealIdVisibleForViewFriends = input.ReadBool();
                            break;
                        }
                    case 40:
                        {
                            IsHiddenFromFriendFinder = input.ReadBool();
                            break;
                        }
                    case 48:
                        {
                            gameInfoPrivacy_ = (Bgs.Protocol.Account.V1.PrivacyInfo.Types.GameInfoPrivacy)input.ReadEnum();
                            break;
                        }
                }
            }
        }

        #region Nested types
        /// <summary>Container for nested types declared in the PrivacyInfo message type.</summary>
        [System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public static partial class Types
        {
            public enum GameInfoPrivacy
            {
                PRIVACY_ME = 0,
                PRIVACY_FRIENDS = 1,
                PRIVACY_EVERYONE = 2,
            }

        }
        #endregion

        System.Collections.BitArray bitArray = new System.Collections.BitArray(7);
    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class ParentalControlInfo : pb::IMessage<ParentalControlInfo>
    {
        private static readonly pb::MessageParser<ParentalControlInfo> _parser = new pb::MessageParser<ParentalControlInfo>(() => new ParentalControlInfo());
        public static pb::MessageParser<ParentalControlInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[20]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public ParentalControlInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public ParentalControlInfo(ParentalControlInfo other) : this()
        {
            timezone_ = other.timezone_;
            minutesPerDay_ = other.minutesPerDay_;
            minutesPerWeek_ = other.minutesPerWeek_;
            canReceiveVoice_ = other.canReceiveVoice_;
            canSendVoice_ = other.canSendVoice_;
            playSchedule_ = other.playSchedule_.Clone();
        }

        public ParentalControlInfo Clone()
        {
            return new ParentalControlInfo(this);
        }

        /// <summary>Field number for the "timezone" field.</summary>
        public const int TimezoneFieldNumber = 3;
        private string timezone_ = "";
        public string Timezone
        {
            get { return timezone_; }
            set
            {
                timezone_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "minutes_per_day" field.</summary>
        public const int MinutesPerDayFieldNumber = 4;
        private uint minutesPerDay_;
        public uint MinutesPerDay
        {
            get { return minutesPerDay_; }
            set
            {
                minutesPerDay_ = value;
            }
        }

        /// <summary>Field number for the "minutes_per_week" field.</summary>
        public const int MinutesPerWeekFieldNumber = 5;
        private uint minutesPerWeek_;
        public uint MinutesPerWeek
        {
            get { return minutesPerWeek_; }
            set
            {
                minutesPerWeek_ = value;
            }
        }

        /// <summary>Field number for the "can_receive_voice" field.</summary>
        public const int CanReceiveVoiceFieldNumber = 6;
        private bool canReceiveVoice_;
        public bool CanReceiveVoice
        {
            get { return canReceiveVoice_; }
            set
            {
                canReceiveVoice_ = value;
            }
        }

        /// <summary>Field number for the "can_send_voice" field.</summary>
        public const int CanSendVoiceFieldNumber = 7;
        private bool canSendVoice_;
        public bool CanSendVoice
        {
            get { return canSendVoice_; }
            set
            {
                canSendVoice_ = value;
            }
        }

        /// <summary>Field number for the "play_schedule" field.</summary>
        public const int PlayScheduleFieldNumber = 8;
        private static readonly pb::FieldCodec<bool> _repeated_playSchedule_codec
            = pb::FieldCodec.ForBool(66);
        private readonly pbc::RepeatedField<bool> playSchedule_ = new pbc::RepeatedField<bool>();
        public pbc::RepeatedField<bool> PlaySchedule
        {
            get { return playSchedule_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as ParentalControlInfo);
        }

        public bool Equals(ParentalControlInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Timezone != other.Timezone) return false;
            if (MinutesPerDay != other.MinutesPerDay) return false;
            if (MinutesPerWeek != other.MinutesPerWeek) return false;
            if (CanReceiveVoice != other.CanReceiveVoice) return false;
            if (CanSendVoice != other.CanSendVoice) return false;
            if (!playSchedule_.Equals(other.playSchedule_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Timezone.Length != 0) hash ^= Timezone.GetHashCode();
            if (MinutesPerDay != 0) hash ^= MinutesPerDay.GetHashCode();
            if (MinutesPerWeek != 0) hash ^= MinutesPerWeek.GetHashCode();
            if (CanReceiveVoice != false) hash ^= CanReceiveVoice.GetHashCode();
            if (CanSendVoice != false) hash ^= CanSendVoice.GetHashCode();
            hash ^= playSchedule_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Timezone.Length != 0)
            {
                output.WriteRawTag(26);
                output.WriteString(Timezone);
            }
            if (MinutesPerDay != 0)
            {
                output.WriteRawTag(32);
                output.WriteUInt32(MinutesPerDay);
            }
            if (MinutesPerWeek != 0)
            {
                output.WriteRawTag(40);
                output.WriteUInt32(MinutesPerWeek);
            }
            if (CanReceiveVoice != false)
            {
                output.WriteRawTag(48);
                output.WriteBool(CanReceiveVoice);
            }
            if (CanSendVoice != false)
            {
                output.WriteRawTag(56);
                output.WriteBool(CanSendVoice);
            }
            playSchedule_.WriteTo(output, _repeated_playSchedule_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Timezone.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Timezone);
            }
            if (MinutesPerDay != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MinutesPerDay);
            }
            if (MinutesPerWeek != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MinutesPerWeek);
            }
            if (CanReceiveVoice != false)
            {
                size += 1 + 1;
            }
            if (CanSendVoice != false)
            {
                size += 1 + 1;
            }
            size += playSchedule_.CalculateSize(_repeated_playSchedule_codec);
            return size;
        }

        public void MergeFrom(ParentalControlInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Timezone.Length != 0)
            {
                Timezone = other.Timezone;
            }
            if (other.MinutesPerDay != 0)
            {
                MinutesPerDay = other.MinutesPerDay;
            }
            if (other.MinutesPerWeek != 0)
            {
                MinutesPerWeek = other.MinutesPerWeek;
            }
            if (other.CanReceiveVoice != false)
            {
                CanReceiveVoice = other.CanReceiveVoice;
            }
            if (other.CanSendVoice != false)
            {
                CanSendVoice = other.CanSendVoice;
            }
            playSchedule_.Add(other.playSchedule_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 26:
                        {
                            Timezone = input.ReadString();
                            break;
                        }
                    case 32:
                        {
                            MinutesPerDay = input.ReadUInt32();
                            break;
                        }
                    case 40:
                        {
                            MinutesPerWeek = input.ReadUInt32();
                            break;
                        }
                    case 48:
                        {
                            CanReceiveVoice = input.ReadBool();
                            break;
                        }
                    case 56:
                        {
                            CanSendVoice = input.ReadBool();
                            break;
                        }
                    case 66:
                    case 64:
                        {
                            playSchedule_.AddEntriesFrom(input, _repeated_playSchedule_codec);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameLevelInfo : pb::IMessage<GameLevelInfo>
    {
        private static readonly pb::MessageParser<GameLevelInfo> _parser = new pb::MessageParser<GameLevelInfo>(() => new GameLevelInfo());
        public static pb::MessageParser<GameLevelInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[21]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameLevelInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameLevelInfo(GameLevelInfo other) : this()
        {
            isTrial_ = other.isTrial_;
            isLifetime_ = other.isLifetime_;
            isRestricted_ = other.isRestricted_;
            isBeta_ = other.isBeta_;
            name_ = other.name_;
            program_ = other.program_;
            licenses_ = other.licenses_.Clone();
            realmPermissions_ = other.realmPermissions_;
        }

        public GameLevelInfo Clone()
        {
            return new GameLevelInfo(this);
        }

        /// <summary>Field number for the "is_trial" field.</summary>
        public const int IsTrialFieldNumber = 4;
        private bool isTrial_;
        public bool IsTrial
        {
            get { return isTrial_; }
            set
            {
                isTrial_ = value;
            }
        }

        /// <summary>Field number for the "is_lifetime" field.</summary>
        public const int IsLifetimeFieldNumber = 5;
        private bool isLifetime_;
        public bool IsLifetime
        {
            get { return isLifetime_; }
            set
            {
                isLifetime_ = value;
            }
        }

        /// <summary>Field number for the "is_restricted" field.</summary>
        public const int IsRestrictedFieldNumber = 6;
        private bool isRestricted_;
        public bool IsRestricted
        {
            get { return isRestricted_; }
            set
            {
                isRestricted_ = value;
            }
        }

        /// <summary>Field number for the "is_beta" field.</summary>
        public const int IsBetaFieldNumber = 7;
        private bool isBeta_;
        public bool IsBeta
        {
            get { return isBeta_; }
            set
            {
                isBeta_ = value;
            }
        }

        /// <summary>Field number for the "name" field.</summary>
        public const int NameFieldNumber = 8;
        private string name_ = "";
        public string Name
        {
            get { return name_; }
            set
            {
                name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "program" field.</summary>
        public const int ProgramFieldNumber = 9;
        private uint program_;
        public uint Program
        {
            get { return program_; }
            set
            {
                program_ = value;
            }
        }

        /// <summary>Field number for the "licenses" field.</summary>
        public const int LicensesFieldNumber = 10;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.AccountLicense> _repeated_licenses_codec
            = pb::FieldCodec.ForMessage(82, Bgs.Protocol.Account.V1.AccountLicense.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> licenses_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.AccountLicense> Licenses
        {
            get { return licenses_; }
        }

        /// <summary>Field number for the "realm_permissions" field.</summary>
        public const int RealmPermissionsFieldNumber = 11;
        private uint realmPermissions_;
        public uint RealmPermissions
        {
            get { return realmPermissions_; }
            set
            {
                realmPermissions_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameLevelInfo);
        }

        public bool Equals(GameLevelInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (IsTrial != other.IsTrial) return false;
            if (IsLifetime != other.IsLifetime) return false;
            if (IsRestricted != other.IsRestricted) return false;
            if (IsBeta != other.IsBeta) return false;
            if (Name != other.Name) return false;
            if (Program != other.Program) return false;
            if (!licenses_.Equals(other.licenses_)) return false;
            if (RealmPermissions != other.RealmPermissions) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (IsTrial != false) hash ^= IsTrial.GetHashCode();
            if (IsLifetime != false) hash ^= IsLifetime.GetHashCode();
            if (IsRestricted != false) hash ^= IsRestricted.GetHashCode();
            if (IsBeta != false) hash ^= IsBeta.GetHashCode();
            if (Name.Length != 0) hash ^= Name.GetHashCode();
            if (Program != 0) hash ^= Program.GetHashCode();
            hash ^= licenses_.GetHashCode();
            if (RealmPermissions != 0) hash ^= RealmPermissions.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (IsTrial != false)
            {
                output.WriteRawTag(32);
                output.WriteBool(IsTrial);
            }
            if (IsLifetime != false)
            {
                output.WriteRawTag(40);
                output.WriteBool(IsLifetime);
            }
            if (IsRestricted != false)
            {
                output.WriteRawTag(48);
                output.WriteBool(IsRestricted);
            }
            if (IsBeta != false)
            {
                output.WriteRawTag(56);
                output.WriteBool(IsBeta);
            }
            if (Name.Length != 0)
            {
                output.WriteRawTag(66);
                output.WriteString(Name);
            }
            if (Program != 0)
            {
                output.WriteRawTag(77);
                output.WriteFixed32(Program);
            }
            licenses_.WriteTo(output, _repeated_licenses_codec);
            if (RealmPermissions != 0)
            {
                output.WriteRawTag(88);
                output.WriteUInt32(RealmPermissions);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (IsTrial != false)
            {
                size += 1 + 1;
            }
            if (IsLifetime != false)
            {
                size += 1 + 1;
            }
            if (IsRestricted != false)
            {
                size += 1 + 1;
            }
            if (IsBeta != false)
            {
                size += 1 + 1;
            }
            if (Name.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
            }
            if (Program != 0)
            {
                size += 1 + 4;
            }
            size += licenses_.CalculateSize(_repeated_licenses_codec);
            if (RealmPermissions != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RealmPermissions);
            }
            return size;
        }

        public void MergeFrom(GameLevelInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.IsTrial != false)
            {
                IsTrial = other.IsTrial;
            }
            if (other.IsLifetime != false)
            {
                IsLifetime = other.IsLifetime;
            }
            if (other.IsRestricted != false)
            {
                IsRestricted = other.IsRestricted;
            }
            if (other.IsBeta != false)
            {
                IsBeta = other.IsBeta;
            }
            if (other.Name.Length != 0)
            {
                Name = other.Name;
            }
            if (other.Program != 0)
            {
                Program = other.Program;
            }
            licenses_.Add(other.licenses_);
            if (other.RealmPermissions != 0)
            {
                RealmPermissions = other.RealmPermissions;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 32:
                        {
                            IsTrial = input.ReadBool();
                            break;
                        }
                    case 40:
                        {
                            IsLifetime = input.ReadBool();
                            break;
                        }
                    case 48:
                        {
                            IsRestricted = input.ReadBool();
                            break;
                        }
                    case 56:
                        {
                            IsBeta = input.ReadBool();
                            break;
                        }
                    case 66:
                        {
                            Name = input.ReadString();
                            break;
                        }
                    case 77:
                        {
                            Program = input.ReadFixed32();
                            break;
                        }
                    case 82:
                        {
                            licenses_.AddEntriesFrom(input, _repeated_licenses_codec);
                            break;
                        }
                    case 88:
                        {
                            RealmPermissions = input.ReadUInt32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameTimeInfo : pb::IMessage<GameTimeInfo>
    {
        private static readonly pb::MessageParser<GameTimeInfo> _parser = new pb::MessageParser<GameTimeInfo>(() => new GameTimeInfo());
        public static pb::MessageParser<GameTimeInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[22]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameTimeInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameTimeInfo(GameTimeInfo other) : this()
        {
            isUnlimitedPlayTime_ = other.isUnlimitedPlayTime_;
            playTimeExpires_ = other.playTimeExpires_;
            isSubscription_ = other.isSubscription_;
            isRecurringSubscription_ = other.isRecurringSubscription_;
        }

        public GameTimeInfo Clone()
        {
            return new GameTimeInfo(this);
        }

        /// <summary>Field number for the "is_unlimited_play_time" field.</summary>
        public const int IsUnlimitedPlayTimeFieldNumber = 3;
        private bool isUnlimitedPlayTime_;
        public bool IsUnlimitedPlayTime
        {
            get { return isUnlimitedPlayTime_; }
            set
            {
                isUnlimitedPlayTime_ = value;
            }
        }

        /// <summary>Field number for the "play_time_expires" field.</summary>
        public const int PlayTimeExpiresFieldNumber = 5;
        private ulong playTimeExpires_;
        public ulong PlayTimeExpires
        {
            get { return playTimeExpires_; }
            set
            {
                playTimeExpires_ = value;
            }
        }

        /// <summary>Field number for the "is_subscription" field.</summary>
        public const int IsSubscriptionFieldNumber = 6;
        private bool isSubscription_;
        public bool IsSubscription
        {
            get { return isSubscription_; }
            set
            {
                isSubscription_ = value;
            }
        }

        /// <summary>Field number for the "is_recurring_subscription" field.</summary>
        public const int IsRecurringSubscriptionFieldNumber = 7;
        private bool isRecurringSubscription_;
        public bool IsRecurringSubscription
        {
            get { return isRecurringSubscription_; }
            set
            {
                isRecurringSubscription_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameTimeInfo);
        }

        public bool Equals(GameTimeInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (IsUnlimitedPlayTime != other.IsUnlimitedPlayTime) return false;
            if (PlayTimeExpires != other.PlayTimeExpires) return false;
            if (IsSubscription != other.IsSubscription) return false;
            if (IsRecurringSubscription != other.IsRecurringSubscription) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (IsUnlimitedPlayTime != false) hash ^= IsUnlimitedPlayTime.GetHashCode();
            if (PlayTimeExpires != 0UL) hash ^= PlayTimeExpires.GetHashCode();
            if (IsSubscription != false) hash ^= IsSubscription.GetHashCode();
            if (IsRecurringSubscription != false) hash ^= IsRecurringSubscription.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (IsUnlimitedPlayTime != false)
            {
                output.WriteRawTag(24);
                output.WriteBool(IsUnlimitedPlayTime);
            }
            if (PlayTimeExpires != 0UL)
            {
                output.WriteRawTag(40);
                output.WriteUInt64(PlayTimeExpires);
            }
            if (IsSubscription != false)
            {
                output.WriteRawTag(48);
                output.WriteBool(IsSubscription);
            }
            if (IsRecurringSubscription != false)
            {
                output.WriteRawTag(56);
                output.WriteBool(IsRecurringSubscription);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (IsUnlimitedPlayTime != false)
            {
                size += 1 + 1;
            }
            if (PlayTimeExpires != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(PlayTimeExpires);
            }
            if (IsSubscription != false)
            {
                size += 1 + 1;
            }
            if (IsRecurringSubscription != false)
            {
                size += 1 + 1;
            }
            return size;
        }

        public void MergeFrom(GameTimeInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.IsUnlimitedPlayTime != false)
            {
                IsUnlimitedPlayTime = other.IsUnlimitedPlayTime;
            }
            if (other.PlayTimeExpires != 0UL)
            {
                PlayTimeExpires = other.PlayTimeExpires;
            }
            if (other.IsSubscription != false)
            {
                IsSubscription = other.IsSubscription;
            }
            if (other.IsRecurringSubscription != false)
            {
                IsRecurringSubscription = other.IsRecurringSubscription;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 24:
                        {
                            IsUnlimitedPlayTime = input.ReadBool();
                            break;
                        }
                    case 40:
                        {
                            PlayTimeExpires = input.ReadUInt64();
                            break;
                        }
                    case 48:
                        {
                            IsSubscription = input.ReadBool();
                            break;
                        }
                    case 56:
                        {
                            IsRecurringSubscription = input.ReadBool();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameTimeRemainingInfo : pb::IMessage<GameTimeRemainingInfo>
    {
        private static readonly pb::MessageParser<GameTimeRemainingInfo> _parser = new pb::MessageParser<GameTimeRemainingInfo>(() => new GameTimeRemainingInfo());
        public static pb::MessageParser<GameTimeRemainingInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[23]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameTimeRemainingInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameTimeRemainingInfo(GameTimeRemainingInfo other) : this()
        {
            minutesRemaining_ = other.minutesRemaining_;
            parentalDailyMinutesRemaining_ = other.parentalDailyMinutesRemaining_;
            parentalWeeklyMinutesRemaining_ = other.parentalWeeklyMinutesRemaining_;
            secondsRemainingUntilKick_ = other.secondsRemainingUntilKick_;
        }

        public GameTimeRemainingInfo Clone()
        {
            return new GameTimeRemainingInfo(this);
        }

        /// <summary>Field number for the "minutes_remaining" field.</summary>
        public const int MinutesRemainingFieldNumber = 1;
        private uint minutesRemaining_;
        public uint MinutesRemaining
        {
            get { return minutesRemaining_; }
            set
            {
                minutesRemaining_ = value;
            }
        }

        /// <summary>Field number for the "parental_daily_minutes_remaining" field.</summary>
        public const int ParentalDailyMinutesRemainingFieldNumber = 2;
        private uint parentalDailyMinutesRemaining_;
        public uint ParentalDailyMinutesRemaining
        {
            get { return parentalDailyMinutesRemaining_; }
            set
            {
                parentalDailyMinutesRemaining_ = value;
            }
        }

        /// <summary>Field number for the "parental_weekly_minutes_remaining" field.</summary>
        public const int ParentalWeeklyMinutesRemainingFieldNumber = 3;
        private uint parentalWeeklyMinutesRemaining_;
        public uint ParentalWeeklyMinutesRemaining
        {
            get { return parentalWeeklyMinutesRemaining_; }
            set
            {
                parentalWeeklyMinutesRemaining_ = value;
            }
        }

        /// <summary>Field number for the "seconds_remaining_until_kick" field.</summary>
        public const int SecondsRemainingUntilKickFieldNumber = 4;
        private uint secondsRemainingUntilKick_;
        public uint SecondsRemainingUntilKick
        {
            get { return secondsRemainingUntilKick_; }
            set
            {
                secondsRemainingUntilKick_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameTimeRemainingInfo);
        }

        public bool Equals(GameTimeRemainingInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (MinutesRemaining != other.MinutesRemaining) return false;
            if (ParentalDailyMinutesRemaining != other.ParentalDailyMinutesRemaining) return false;
            if (ParentalWeeklyMinutesRemaining != other.ParentalWeeklyMinutesRemaining) return false;
            if (SecondsRemainingUntilKick != other.SecondsRemainingUntilKick) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (MinutesRemaining != 0) hash ^= MinutesRemaining.GetHashCode();
            if (ParentalDailyMinutesRemaining != 0) hash ^= ParentalDailyMinutesRemaining.GetHashCode();
            if (ParentalWeeklyMinutesRemaining != 0) hash ^= ParentalWeeklyMinutesRemaining.GetHashCode();
            if (SecondsRemainingUntilKick != 0) hash ^= SecondsRemainingUntilKick.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (MinutesRemaining != 0)
            {
                output.WriteRawTag(8);
                output.WriteUInt32(MinutesRemaining);
            }
            if (ParentalDailyMinutesRemaining != 0)
            {
                output.WriteRawTag(16);
                output.WriteUInt32(ParentalDailyMinutesRemaining);
            }
            if (ParentalWeeklyMinutesRemaining != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(ParentalWeeklyMinutesRemaining);
            }
            if (SecondsRemainingUntilKick != 0)
            {
                output.WriteRawTag(32);
                output.WriteUInt32(SecondsRemainingUntilKick);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (MinutesRemaining != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MinutesRemaining);
            }
            if (ParentalDailyMinutesRemaining != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ParentalDailyMinutesRemaining);
            }
            if (ParentalWeeklyMinutesRemaining != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ParentalWeeklyMinutesRemaining);
            }
            if (SecondsRemainingUntilKick != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SecondsRemainingUntilKick);
            }
            return size;
        }

        public void MergeFrom(GameTimeRemainingInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.MinutesRemaining != 0)
            {
                MinutesRemaining = other.MinutesRemaining;
            }
            if (other.ParentalDailyMinutesRemaining != 0)
            {
                ParentalDailyMinutesRemaining = other.ParentalDailyMinutesRemaining;
            }
            if (other.ParentalWeeklyMinutesRemaining != 0)
            {
                ParentalWeeklyMinutesRemaining = other.ParentalWeeklyMinutesRemaining;
            }
            if (other.SecondsRemainingUntilKick != 0)
            {
                SecondsRemainingUntilKick = other.SecondsRemainingUntilKick;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            MinutesRemaining = input.ReadUInt32();
                            break;
                        }
                    case 16:
                        {
                            ParentalDailyMinutesRemaining = input.ReadUInt32();
                            break;
                        }
                    case 24:
                        {
                            ParentalWeeklyMinutesRemaining = input.ReadUInt32();
                            break;
                        }
                    case 32:
                        {
                            SecondsRemainingUntilKick = input.ReadUInt32();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameStatus : pb::IMessage<GameStatus>
    {
        private static readonly pb::MessageParser<GameStatus> _parser = new pb::MessageParser<GameStatus>(() => new GameStatus());
        public static pb::MessageParser<GameStatus> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[24]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameStatus()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameStatus(GameStatus other) : this()
        {
            isSuspended_ = other.isSuspended_;
            isBanned_ = other.isBanned_;
            suspensionExpires_ = other.suspensionExpires_;
            program_ = other.program_;
            isLocked_ = other.isLocked_;
            isBamUnlockable_ = other.isBamUnlockable_;
        }

        public GameStatus Clone()
        {
            return new GameStatus(this);
        }

        /// <summary>Field number for the "is_suspended" field.</summary>
        public const int IsSuspendedFieldNumber = 4;
        private bool isSuspended_;
        public bool IsSuspended
        {
            get { return isSuspended_; }
            set
            {
                bitArray.Set(IsSuspendedFieldNumber, true);
                isSuspended_ = value;
            }
        }

        /// <summary>Field number for the "is_banned" field.</summary>
        public const int IsBannedFieldNumber = 5;
        private bool isBanned_;
        public bool IsBanned
        {
            get { return isBanned_; }
            set
            {
                bitArray.Set(IsBannedFieldNumber, true);
                isBanned_ = value;
            }
        }

        /// <summary>Field number for the "suspension_expires" field.</summary>
        public const int SuspensionExpiresFieldNumber = 6;
        private ulong suspensionExpires_;
        public ulong SuspensionExpires
        {
            get { return suspensionExpires_; }
            set
            {
                bitArray.Set(SuspensionExpiresFieldNumber, true);
                suspensionExpires_ = value;
            }
        }

        /// <summary>Field number for the "program" field.</summary>
        public const int ProgramFieldNumber = 7;
        private uint program_;
        public uint Program
        {
            get { return program_; }
            set
            {
                bitArray.Set(ProgramFieldNumber, true);
                program_ = value;
            }
        }

        /// <summary>Field number for the "is_locked" field.</summary>
        public const int IsLockedFieldNumber = 8;
        private bool isLocked_;
        public bool IsLocked
        {
            get { return isLocked_; }
            set
            {
                bitArray.Set(IsLockedFieldNumber, true);
                isLocked_ = value;
            }
        }

        /// <summary>Field number for the "is_bam_unlockable" field.</summary>
        public const int IsBamUnlockableFieldNumber = 9;
        private bool isBamUnlockable_;
        public bool IsBamUnlockable
        {
            get { return isBamUnlockable_; }
            set
            {
                bitArray.Set(IsBamUnlockableFieldNumber, true);
                isBamUnlockable_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameStatus);
        }

        public bool Equals(GameStatus other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (IsSuspended != other.IsSuspended) return false;
            if (IsBanned != other.IsBanned) return false;
            if (SuspensionExpires != other.SuspensionExpires) return false;
            if (Program != other.Program) return false;
            if (IsLocked != other.IsLocked) return false;
            if (IsBamUnlockable != other.IsBamUnlockable) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (IsSuspended != false) hash ^= IsSuspended.GetHashCode();
            if (IsBanned != false) hash ^= IsBanned.GetHashCode();
            if (SuspensionExpires != 0UL) hash ^= SuspensionExpires.GetHashCode();
            if (Program != 0) hash ^= Program.GetHashCode();
            if (IsLocked != false) hash ^= IsLocked.GetHashCode();
            if (IsBamUnlockable != false) hash ^= IsBamUnlockable.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (bitArray.Get(IsSuspendedFieldNumber))
            {
                output.WriteRawTag(32);
                output.WriteBool(IsSuspended);
            }
            if (bitArray.Get(IsBannedFieldNumber))
            {
                output.WriteRawTag(40);
                output.WriteBool(IsBanned);
            }
            if (bitArray.Get(SuspensionExpiresFieldNumber))
            {
                output.WriteRawTag(48);
                output.WriteUInt64(SuspensionExpires);
            }
            if (bitArray.Get(ProgramFieldNumber))
            {
                output.WriteRawTag(61);
                output.WriteFixed32(Program);
            }
            if (bitArray.Get(IsLockedFieldNumber))
            {
                output.WriteRawTag(64);
                output.WriteBool(IsLocked);
            }
            if (bitArray.Get(IsBamUnlockableFieldNumber))
            {
                output.WriteRawTag(72);
                output.WriteBool(IsBamUnlockable);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (bitArray.Get(IsSuspendedFieldNumber))
            {
                size += 1 + 1;
            }
            if (bitArray.Get(IsBannedFieldNumber))
            {
                size += 1 + 1;
            }
            if (bitArray.Get(SuspensionExpiresFieldNumber))
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(SuspensionExpires);
            }
            if (bitArray.Get(ProgramFieldNumber))
            {
                size += 1 + 4;
            }
            if (bitArray.Get(IsLockedFieldNumber))
            {
                size += 1 + 1;
            }
            if (bitArray.Get(IsBamUnlockableFieldNumber))
            {
                size += 1 + 1;
            }
            return size;
        }

        public void MergeFrom(GameStatus other)
        {
            if (other == null)
            {
                return;
            }
            if (other.IsSuspended != false)
            {
                IsSuspended = other.IsSuspended;
            }
            if (other.IsBanned != false)
            {
                IsBanned = other.IsBanned;
            }
            if (other.SuspensionExpires != 0UL)
            {
                SuspensionExpires = other.SuspensionExpires;
            }
            if (other.Program != 0)
            {
                Program = other.Program;
            }
            if (other.IsLocked != false)
            {
                IsLocked = other.IsLocked;
            }
            if (other.IsBamUnlockable != false)
            {
                IsBamUnlockable = other.IsBamUnlockable;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 32:
                        {
                            IsSuspended = input.ReadBool();
                            break;
                        }
                    case 40:
                        {
                            IsBanned = input.ReadBool();
                            break;
                        }
                    case 48:
                        {
                            SuspensionExpires = input.ReadUInt64();
                            break;
                        }
                    case 61:
                        {
                            Program = input.ReadFixed32();
                            break;
                        }
                    case 64:
                        {
                            IsLocked = input.ReadBool();
                            break;
                        }
                    case 72:
                        {
                            IsBamUnlockable = input.ReadBool();
                            break;
                        }
                }
            }
        }

        System.Collections.BitArray bitArray = new System.Collections.BitArray(10);
    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class RAFInfo : pb::IMessage<RAFInfo>
    {
        private static readonly pb::MessageParser<RAFInfo> _parser = new pb::MessageParser<RAFInfo>(() => new RAFInfo());
        public static pb::MessageParser<RAFInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[25]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public RAFInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public RAFInfo(RAFInfo other) : this()
        {
            rafInfo_ = other.rafInfo_;
        }

        public RAFInfo Clone()
        {
            return new RAFInfo(this);
        }

        /// <summary>Field number for the "raf_info" field.</summary>
        public const int RafInfoFieldNumber = 1;
        private pb::ByteString rafInfo_ = pb::ByteString.Empty;
        public pb::ByteString RafInfo
        {
            get { return rafInfo_; }
            set
            {
                rafInfo_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as RAFInfo);
        }

        public bool Equals(RAFInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (RafInfo != other.RafInfo) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (RafInfo.Length != 0) hash ^= RafInfo.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (RafInfo.Length != 0)
            {
                output.WriteRawTag(10);
                output.WriteBytes(RafInfo);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (RafInfo.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeBytesSize(RafInfo);
            }
            return size;
        }

        public void MergeFrom(RAFInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.RafInfo.Length != 0)
            {
                RafInfo = other.RafInfo;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            RafInfo = input.ReadBytes();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameSessionInfo : pb::IMessage<GameSessionInfo>
    {
        private static readonly pb::MessageParser<GameSessionInfo> _parser = new pb::MessageParser<GameSessionInfo>(() => new GameSessionInfo());
        public static pb::MessageParser<GameSessionInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[26]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameSessionInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameSessionInfo(GameSessionInfo other) : this()
        {
            startTime_ = other.startTime_;
            Location = other.location_ != null ? other.Location.Clone() : null;
            hasBenefactor_ = other.hasBenefactor_;
            isUsingIgr_ = other.isUsingIgr_;
            parentalControlsActive_ = other.parentalControlsActive_;
            startTimeSec_ = other.startTimeSec_;
        }

        public GameSessionInfo Clone()
        {
            return new GameSessionInfo(this);
        }

        /// <summary>Field number for the "start_time" field.</summary>
        public const int StartTimeFieldNumber = 3;
        private uint startTime_;
        [System.ObsoleteAttribute()]
        public uint StartTime
        {
            get { return startTime_; }
            set
            {
                startTime_ = value;
            }
        }

        /// <summary>Field number for the "location" field.</summary>
        public const int LocationFieldNumber = 4;
        private Bgs.Protocol.Account.V1.GameSessionLocation location_;
        public Bgs.Protocol.Account.V1.GameSessionLocation Location
        {
            get { return location_; }
            set
            {
                location_ = value;
            }
        }

        /// <summary>Field number for the "has_benefactor" field.</summary>
        public const int HasBenefactorFieldNumber = 5;
        private bool hasBenefactor_;
        public bool HasBenefactor
        {
            get { return hasBenefactor_; }
            set
            {
                hasBenefactor_ = value;
            }
        }

        /// <summary>Field number for the "is_using_igr" field.</summary>
        public const int IsUsingIgrFieldNumber = 6;
        private bool isUsingIgr_;
        public bool IsUsingIgr
        {
            get { return isUsingIgr_; }
            set
            {
                isUsingIgr_ = value;
            }
        }

        /// <summary>Field number for the "parental_controls_active" field.</summary>
        public const int ParentalControlsActiveFieldNumber = 7;
        private bool parentalControlsActive_;
        public bool ParentalControlsActive
        {
            get { return parentalControlsActive_; }
            set
            {
                parentalControlsActive_ = value;
            }
        }

        /// <summary>Field number for the "start_time_sec" field.</summary>
        public const int StartTimeSecFieldNumber = 8;
        private ulong startTimeSec_;
        public ulong StartTimeSec
        {
            get { return startTimeSec_; }
            set
            {
                startTimeSec_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameSessionInfo);
        }

        public bool Equals(GameSessionInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (StartTime != other.StartTime) return false;
            if (!object.Equals(Location, other.Location)) return false;
            if (HasBenefactor != other.HasBenefactor) return false;
            if (IsUsingIgr != other.IsUsingIgr) return false;
            if (ParentalControlsActive != other.ParentalControlsActive) return false;
            if (StartTimeSec != other.StartTimeSec) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (StartTime != 0) hash ^= StartTime.GetHashCode();
            if (location_ != null) hash ^= Location.GetHashCode();
            if (HasBenefactor != false) hash ^= HasBenefactor.GetHashCode();
            if (IsUsingIgr != false) hash ^= IsUsingIgr.GetHashCode();
            if (ParentalControlsActive != false) hash ^= ParentalControlsActive.GetHashCode();
            if (StartTimeSec != 0UL) hash ^= StartTimeSec.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (StartTime != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(StartTime);
            }
            if (location_ != null)
            {
                output.WriteRawTag(34);
                output.WriteMessage(Location);
            }
            if (HasBenefactor != false)
            {
                output.WriteRawTag(40);
                output.WriteBool(HasBenefactor);
            }
            if (IsUsingIgr != false)
            {
                output.WriteRawTag(48);
                output.WriteBool(IsUsingIgr);
            }
            if (ParentalControlsActive != false)
            {
                output.WriteRawTag(56);
                output.WriteBool(ParentalControlsActive);
            }
            if (StartTimeSec != 0UL)
            {
                output.WriteRawTag(64);
                output.WriteUInt64(StartTimeSec);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (StartTime != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(StartTime);
            }
            if (location_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(Location);
            }
            if (HasBenefactor != false)
            {
                size += 1 + 1;
            }
            if (IsUsingIgr != false)
            {
                size += 1 + 1;
            }
            if (ParentalControlsActive != false)
            {
                size += 1 + 1;
            }
            if (StartTimeSec != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(StartTimeSec);
            }
            return size;
        }

        public void MergeFrom(GameSessionInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.StartTime != 0)
            {
                StartTime = other.StartTime;
            }
            if (other.location_ != null)
            {
                if (location_ == null)
                {
                    location_ = new Bgs.Protocol.Account.V1.GameSessionLocation();
                }
                Location.MergeFrom(other.Location);
            }
            if (other.HasBenefactor != false)
            {
                HasBenefactor = other.HasBenefactor;
            }
            if (other.IsUsingIgr != false)
            {
                IsUsingIgr = other.IsUsingIgr;
            }
            if (other.ParentalControlsActive != false)
            {
                ParentalControlsActive = other.ParentalControlsActive;
            }
            if (other.StartTimeSec != 0UL)
            {
                StartTimeSec = other.StartTimeSec;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 24:
                        {
                            StartTime = input.ReadUInt32();
                            break;
                        }
                    case 34:
                        {
                            if (location_ == null)
                            {
                                location_ = new Bgs.Protocol.Account.V1.GameSessionLocation();
                            }
                            input.ReadMessage(location_);
                            break;
                        }
                    case 40:
                        {
                            HasBenefactor = input.ReadBool();
                            break;
                        }
                    case 48:
                        {
                            IsUsingIgr = input.ReadBool();
                            break;
                        }
                    case 56:
                        {
                            ParentalControlsActive = input.ReadBool();
                            break;
                        }
                    case 64:
                        {
                            StartTimeSec = input.ReadUInt64();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameSessionUpdateInfo : pb::IMessage<GameSessionUpdateInfo>
    {
        private static readonly pb::MessageParser<GameSessionUpdateInfo> _parser = new pb::MessageParser<GameSessionUpdateInfo>(() => new GameSessionUpdateInfo());
        public static pb::MessageParser<GameSessionUpdateInfo> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[27]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameSessionUpdateInfo()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameSessionUpdateInfo(GameSessionUpdateInfo other) : this()
        {
            Cais = other.cais_ != null ? other.Cais.Clone() : null;
        }

        public GameSessionUpdateInfo Clone()
        {
            return new GameSessionUpdateInfo(this);
        }

        /// <summary>Field number for the "cais" field.</summary>
        public const int CaisFieldNumber = 8;
        private Bgs.Protocol.Account.V1.CAIS cais_;
        public Bgs.Protocol.Account.V1.CAIS Cais
        {
            get { return cais_; }
            set
            {
                cais_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameSessionUpdateInfo);
        }

        public bool Equals(GameSessionUpdateInfo other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(Cais, other.Cais)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (cais_ != null) hash ^= Cais.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (cais_ != null)
            {
                output.WriteRawTag(66);
                output.WriteMessage(Cais);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (cais_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(Cais);
            }
            return size;
        }

        public void MergeFrom(GameSessionUpdateInfo other)
        {
            if (other == null)
            {
                return;
            }
            if (other.cais_ != null)
            {
                if (cais_ == null)
                {
                    cais_ = new Bgs.Protocol.Account.V1.CAIS();
                }
                Cais.MergeFrom(other.Cais);
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 66:
                        {
                            if (cais_ == null)
                            {
                                cais_ = new Bgs.Protocol.Account.V1.CAIS();
                            }
                            input.ReadMessage(cais_);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameSessionLocation : pb::IMessage<GameSessionLocation>
    {
        private static readonly pb::MessageParser<GameSessionLocation> _parser = new pb::MessageParser<GameSessionLocation>(() => new GameSessionLocation());
        public static pb::MessageParser<GameSessionLocation> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[28]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameSessionLocation()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameSessionLocation(GameSessionLocation other) : this()
        {
            ipAddress_ = other.ipAddress_;
            country_ = other.country_;
            city_ = other.city_;
        }

        public GameSessionLocation Clone()
        {
            return new GameSessionLocation(this);
        }

        /// <summary>Field number for the "ip_address" field.</summary>
        public const int IpAddressFieldNumber = 1;
        private string ipAddress_ = "";
        public string IpAddress
        {
            get { return ipAddress_; }
            set
            {
                ipAddress_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "country" field.</summary>
        public const int CountryFieldNumber = 2;
        private uint country_;
        public uint Country
        {
            get { return country_; }
            set
            {
                country_ = value;
            }
        }

        /// <summary>Field number for the "city" field.</summary>
        public const int CityFieldNumber = 3;
        private string city_ = "";
        public string City
        {
            get { return city_; }
            set
            {
                city_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameSessionLocation);
        }

        public bool Equals(GameSessionLocation other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (IpAddress != other.IpAddress) return false;
            if (Country != other.Country) return false;
            if (City != other.City) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (IpAddress.Length != 0) hash ^= IpAddress.GetHashCode();
            if (Country != 0) hash ^= Country.GetHashCode();
            if (City.Length != 0) hash ^= City.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (IpAddress.Length != 0)
            {
                output.WriteRawTag(10);
                output.WriteString(IpAddress);
            }
            if (Country != 0)
            {
                output.WriteRawTag(16);
                output.WriteUInt32(Country);
            }
            if (City.Length != 0)
            {
                output.WriteRawTag(26);
                output.WriteString(City);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (IpAddress.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(IpAddress);
            }
            if (Country != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Country);
            }
            if (City.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(City);
            }
            return size;
        }

        public void MergeFrom(GameSessionLocation other)
        {
            if (other == null)
            {
                return;
            }
            if (other.IpAddress.Length != 0)
            {
                IpAddress = other.IpAddress;
            }
            if (other.Country != 0)
            {
                Country = other.Country;
            }
            if (other.City.Length != 0)
            {
                City = other.City;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            IpAddress = input.ReadString();
                            break;
                        }
                    case 16:
                        {
                            Country = input.ReadUInt32();
                            break;
                        }
                    case 26:
                        {
                            City = input.ReadString();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class CAIS : pb::IMessage<CAIS>
    {
        private static readonly pb::MessageParser<CAIS> _parser = new pb::MessageParser<CAIS>(() => new CAIS());
        public static pb::MessageParser<CAIS> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[29]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public CAIS()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public CAIS(CAIS other) : this()
        {
            playedMinutes_ = other.playedMinutes_;
            restedMinutes_ = other.restedMinutes_;
            lastHeardTime_ = other.lastHeardTime_;
        }

        public CAIS Clone()
        {
            return new CAIS(this);
        }

        /// <summary>Field number for the "played_minutes" field.</summary>
        public const int PlayedMinutesFieldNumber = 1;
        private uint playedMinutes_;
        public uint PlayedMinutes
        {
            get { return playedMinutes_; }
            set
            {
                playedMinutes_ = value;
            }
        }

        /// <summary>Field number for the "rested_minutes" field.</summary>
        public const int RestedMinutesFieldNumber = 2;
        private uint restedMinutes_;
        public uint RestedMinutes
        {
            get { return restedMinutes_; }
            set
            {
                restedMinutes_ = value;
            }
        }

        /// <summary>Field number for the "last_heard_time" field.</summary>
        public const int LastHeardTimeFieldNumber = 3;
        private ulong lastHeardTime_;
        public ulong LastHeardTime
        {
            get { return lastHeardTime_; }
            set
            {
                lastHeardTime_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as CAIS);
        }

        public bool Equals(CAIS other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (PlayedMinutes != other.PlayedMinutes) return false;
            if (RestedMinutes != other.RestedMinutes) return false;
            if (LastHeardTime != other.LastHeardTime) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (PlayedMinutes != 0) hash ^= PlayedMinutes.GetHashCode();
            if (RestedMinutes != 0) hash ^= RestedMinutes.GetHashCode();
            if (LastHeardTime != 0UL) hash ^= LastHeardTime.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (PlayedMinutes != 0)
            {
                output.WriteRawTag(8);
                output.WriteUInt32(PlayedMinutes);
            }
            if (RestedMinutes != 0)
            {
                output.WriteRawTag(16);
                output.WriteUInt32(RestedMinutes);
            }
            if (LastHeardTime != 0UL)
            {
                output.WriteRawTag(24);
                output.WriteUInt64(LastHeardTime);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (PlayedMinutes != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(PlayedMinutes);
            }
            if (RestedMinutes != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RestedMinutes);
            }
            if (LastHeardTime != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LastHeardTime);
            }
            return size;
        }

        public void MergeFrom(CAIS other)
        {
            if (other == null)
            {
                return;
            }
            if (other.PlayedMinutes != 0)
            {
                PlayedMinutes = other.PlayedMinutes;
            }
            if (other.RestedMinutes != 0)
            {
                RestedMinutes = other.RestedMinutes;
            }
            if (other.LastHeardTime != 0UL)
            {
                LastHeardTime = other.LastHeardTime;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 8:
                        {
                            PlayedMinutes = input.ReadUInt32();
                            break;
                        }
                    case 16:
                        {
                            RestedMinutes = input.ReadUInt32();
                            break;
                        }
                    case 24:
                        {
                            LastHeardTime = input.ReadUInt64();
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountList : pb::IMessage<GameAccountList>
    {
        private static readonly pb::MessageParser<GameAccountList> _parser = new pb::MessageParser<GameAccountList>(() => new GameAccountList());
        public static pb::MessageParser<GameAccountList> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[30]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountList()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountList(GameAccountList other) : this()
        {
            region_ = other.region_;
            handle_ = other.handle_.Clone();
        }

        public GameAccountList Clone()
        {
            return new GameAccountList(this);
        }

        /// <summary>Field number for the "region" field.</summary>
        public const int RegionFieldNumber = 3;
        private uint region_;
        public uint Region
        {
            get { return region_; }
            set
            {
                region_ = value;
            }
        }

        /// <summary>Field number for the "handle" field.</summary>
        public const int HandleFieldNumber = 4;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.GameAccountHandle> _repeated_handle_codec
            = pb::FieldCodec.ForMessage(34, Bgs.Protocol.Account.V1.GameAccountHandle.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountHandle> handle_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountHandle>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountHandle> Handle
        {
            get { return handle_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountList);
        }

        public bool Equals(GameAccountList other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Region != other.Region) return false;
            if (!handle_.Equals(other.handle_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Region != 0) hash ^= Region.GetHashCode();
            hash ^= handle_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Region != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(Region);
            }
            handle_.WriteTo(output, _repeated_handle_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Region != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Region);
            }
            size += handle_.CalculateSize(_repeated_handle_codec);
            return size;
        }

        public void MergeFrom(GameAccountList other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Region != 0)
            {
                Region = other.Region;
            }
            handle_.Add(other.handle_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 24:
                        {
                            Region = input.ReadUInt32();
                            break;
                        }
                    case 34:
                        {
                            handle_.AddEntriesFrom(input, _repeated_handle_codec);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountState : pb::IMessage<AccountState>
    {
        private static readonly pb::MessageParser<AccountState> _parser = new pb::MessageParser<AccountState>(() => new AccountState());
        public static pb::MessageParser<AccountState> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[31]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountState()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountState(AccountState other) : this()
        {
            AccountLevelInfo = other.accountLevelInfo_ != null ? other.AccountLevelInfo.Clone() : null;
            PrivacyInfo = other.privacyInfo_ != null ? other.PrivacyInfo.Clone() : null;
            ParentalControlInfo = other.parentalControlInfo_ != null ? other.ParentalControlInfo.Clone() : null;
            gameLevelInfo_ = other.gameLevelInfo_.Clone();
            gameStatus_ = other.gameStatus_.Clone();
            gameAccounts_ = other.gameAccounts_.Clone();
        }

        public AccountState Clone()
        {
            return new AccountState(this);
        }

        /// <summary>Field number for the "account_level_info" field.</summary>
        public const int AccountLevelInfoFieldNumber = 1;
        private Bgs.Protocol.Account.V1.AccountLevelInfo accountLevelInfo_;
        public Bgs.Protocol.Account.V1.AccountLevelInfo AccountLevelInfo
        {
            get { return accountLevelInfo_; }
            set
            {
                accountLevelInfo_ = value;
            }
        }

        /// <summary>Field number for the "privacy_info" field.</summary>
        public const int PrivacyInfoFieldNumber = 2;
        private Bgs.Protocol.Account.V1.PrivacyInfo privacyInfo_;
        public Bgs.Protocol.Account.V1.PrivacyInfo PrivacyInfo
        {
            get { return privacyInfo_; }
            set
            {
                privacyInfo_ = value;
            }
        }

        /// <summary>Field number for the "parental_control_info" field.</summary>
        public const int ParentalControlInfoFieldNumber = 3;
        private Bgs.Protocol.Account.V1.ParentalControlInfo parentalControlInfo_;
        public Bgs.Protocol.Account.V1.ParentalControlInfo ParentalControlInfo
        {
            get { return parentalControlInfo_; }
            set
            {
                parentalControlInfo_ = value;
            }
        }

        /// <summary>Field number for the "game_level_info" field.</summary>
        public const int GameLevelInfoFieldNumber = 5;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.GameLevelInfo> _repeated_gameLevelInfo_codec
            = pb::FieldCodec.ForMessage(42, Bgs.Protocol.Account.V1.GameLevelInfo.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.GameLevelInfo> gameLevelInfo_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.GameLevelInfo>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.GameLevelInfo> GameLevelInfo
        {
            get { return gameLevelInfo_; }
        }

        /// <summary>Field number for the "game_status" field.</summary>
        public const int GameStatusFieldNumber = 6;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.GameStatus> _repeated_gameStatus_codec
            = pb::FieldCodec.ForMessage(50, Bgs.Protocol.Account.V1.GameStatus.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.GameStatus> gameStatus_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.GameStatus>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.GameStatus> GameStatus
        {
            get { return gameStatus_; }
        }

        /// <summary>Field number for the "game_accounts" field.</summary>
        public const int GameAccountsFieldNumber = 7;
        private static readonly pb::FieldCodec<Bgs.Protocol.Account.V1.GameAccountList> _repeated_gameAccounts_codec
            = pb::FieldCodec.ForMessage(58, Bgs.Protocol.Account.V1.GameAccountList.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountList> gameAccounts_ = new pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountList>();
        public pbc::RepeatedField<Bgs.Protocol.Account.V1.GameAccountList> GameAccounts
        {
            get { return gameAccounts_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountState);
        }

        public bool Equals(AccountState other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(AccountLevelInfo, other.AccountLevelInfo)) return false;
            if (!object.Equals(PrivacyInfo, other.PrivacyInfo)) return false;
            if (!object.Equals(ParentalControlInfo, other.ParentalControlInfo)) return false;
            if (!gameLevelInfo_.Equals(other.gameLevelInfo_)) return false;
            if (!gameStatus_.Equals(other.gameStatus_)) return false;
            if (!gameAccounts_.Equals(other.gameAccounts_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (accountLevelInfo_ != null) hash ^= AccountLevelInfo.GetHashCode();
            if (privacyInfo_ != null) hash ^= PrivacyInfo.GetHashCode();
            if (parentalControlInfo_ != null) hash ^= ParentalControlInfo.GetHashCode();
            hash ^= gameLevelInfo_.GetHashCode();
            hash ^= gameStatus_.GetHashCode();
            hash ^= gameAccounts_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (accountLevelInfo_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(AccountLevelInfo);
            }
            if (privacyInfo_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(PrivacyInfo);
            }
            if (parentalControlInfo_ != null)
            {
                output.WriteRawTag(26);
                output.WriteMessage(ParentalControlInfo);
            }
            gameLevelInfo_.WriteTo(output, _repeated_gameLevelInfo_codec);
            gameStatus_.WriteTo(output, _repeated_gameStatus_codec);
            gameAccounts_.WriteTo(output, _repeated_gameAccounts_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            if (accountLevelInfo_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(AccountLevelInfo);
            }
            if (privacyInfo_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(PrivacyInfo);
            }
            if (parentalControlInfo_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(ParentalControlInfo);
            }
            size += gameLevelInfo_.CalculateSize(_repeated_gameLevelInfo_codec);
            size += gameStatus_.CalculateSize(_repeated_gameStatus_codec);
            size += gameAccounts_.CalculateSize(_repeated_gameAccounts_codec);
            return size;
        }

        public void MergeFrom(AccountState other)
        {
            if (other == null)
            {
                return;
            }
            if (other.accountLevelInfo_ != null)
            {
                if (accountLevelInfo_ == null)
                {
                    accountLevelInfo_ = new Bgs.Protocol.Account.V1.AccountLevelInfo();
                }
                AccountLevelInfo.MergeFrom(other.AccountLevelInfo);
            }
            if (other.privacyInfo_ != null)
            {
                if (privacyInfo_ == null)
                {
                    privacyInfo_ = new Bgs.Protocol.Account.V1.PrivacyInfo();
                }
                PrivacyInfo.MergeFrom(other.PrivacyInfo);
            }
            if (other.parentalControlInfo_ != null)
            {
                if (parentalControlInfo_ == null)
                {
                    parentalControlInfo_ = new Bgs.Protocol.Account.V1.ParentalControlInfo();
                }
                ParentalControlInfo.MergeFrom(other.ParentalControlInfo);
            }
            gameLevelInfo_.Add(other.gameLevelInfo_);
            gameStatus_.Add(other.gameStatus_);
            gameAccounts_.Add(other.gameAccounts_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (accountLevelInfo_ == null)
                            {
                                accountLevelInfo_ = new Bgs.Protocol.Account.V1.AccountLevelInfo();
                            }
                            input.ReadMessage(accountLevelInfo_);
                            break;
                        }
                    case 18:
                        {
                            if (privacyInfo_ == null)
                            {
                                privacyInfo_ = new Bgs.Protocol.Account.V1.PrivacyInfo();
                            }
                            input.ReadMessage(privacyInfo_);
                            break;
                        }
                    case 26:
                        {
                            if (parentalControlInfo_ == null)
                            {
                                parentalControlInfo_ = new Bgs.Protocol.Account.V1.ParentalControlInfo();
                            }
                            input.ReadMessage(parentalControlInfo_);
                            break;
                        }
                    case 42:
                        {
                            gameLevelInfo_.AddEntriesFrom(input, _repeated_gameLevelInfo_codec);
                            break;
                        }
                    case 50:
                        {
                            gameStatus_.AddEntriesFrom(input, _repeated_gameStatus_codec);
                            break;
                        }
                    case 58:
                        {
                            gameAccounts_.AddEntriesFrom(input, _repeated_gameAccounts_codec);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AccountStateTagged : pb::IMessage<AccountStateTagged>
    {
        private static readonly pb::MessageParser<AccountStateTagged> _parser = new pb::MessageParser<AccountStateTagged>(() => new AccountStateTagged());
        public static pb::MessageParser<AccountStateTagged> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[32]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AccountStateTagged()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AccountStateTagged(AccountStateTagged other) : this()
        {
            AccountState = other.accountState_ != null ? other.AccountState.Clone() : null;
            AccountTags = other.accountTags_ != null ? other.AccountTags.Clone() : null;
        }

        public AccountStateTagged Clone()
        {
            return new AccountStateTagged(this);
        }

        /// <summary>Field number for the "account_state" field.</summary>
        public const int AccountStateFieldNumber = 1;
        private Bgs.Protocol.Account.V1.AccountState accountState_;
        public Bgs.Protocol.Account.V1.AccountState AccountState
        {
            get { return accountState_; }
            set
            {
                accountState_ = value;
            }
        }

        /// <summary>Field number for the "account_tags" field.</summary>
        public const int AccountTagsFieldNumber = 2;
        private Bgs.Protocol.Account.V1.AccountFieldTags accountTags_;
        public Bgs.Protocol.Account.V1.AccountFieldTags AccountTags
        {
            get { return accountTags_; }
            set
            {
                accountTags_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AccountStateTagged);
        }

        public bool Equals(AccountStateTagged other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(AccountState, other.AccountState)) return false;
            if (!object.Equals(AccountTags, other.AccountTags)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (accountState_ != null) hash ^= AccountState.GetHashCode();
            if (accountTags_ != null) hash ^= AccountTags.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (accountState_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(AccountState);
            }
            if (accountTags_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(AccountTags);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (accountState_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(AccountState);
            }
            if (accountTags_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(AccountTags);
            }
            return size;
        }

        public void MergeFrom(AccountStateTagged other)
        {
            if (other == null)
            {
                return;
            }
            if (other.accountState_ != null)
            {
                if (accountState_ == null)
                {
                    accountState_ = new Bgs.Protocol.Account.V1.AccountState();
                }
                AccountState.MergeFrom(other.AccountState);
            }
            if (other.accountTags_ != null)
            {
                if (accountTags_ == null)
                {
                    accountTags_ = new Bgs.Protocol.Account.V1.AccountFieldTags();
                }
                AccountTags.MergeFrom(other.AccountTags);
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (accountState_ == null)
                            {
                                accountState_ = new Bgs.Protocol.Account.V1.AccountState();
                            }
                            input.ReadMessage(accountState_);
                            break;
                        }
                    case 18:
                        {
                            if (accountTags_ == null)
                            {
                                accountTags_ = new Bgs.Protocol.Account.V1.AccountFieldTags();
                            }
                            input.ReadMessage(accountTags_);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountState : pb::IMessage<GameAccountState>
    {
        private static readonly pb::MessageParser<GameAccountState> _parser = new pb::MessageParser<GameAccountState>(() => new GameAccountState());
        public static pb::MessageParser<GameAccountState> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[33]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountState()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountState(GameAccountState other) : this()
        {
            GameLevelInfo = other.gameLevelInfo_ != null ? other.GameLevelInfo.Clone() : null;
            GameTimeInfo = other.gameTimeInfo_ != null ? other.GameTimeInfo.Clone() : null;
            GameStatus = other.gameStatus_ != null ? other.GameStatus.Clone() : null;
            RafInfo = other.rafInfo_ != null ? other.RafInfo.Clone() : null;
        }

        public GameAccountState Clone()
        {
            return new GameAccountState(this);
        }

        /// <summary>Field number for the "game_level_info" field.</summary>
        public const int GameLevelInfoFieldNumber = 1;
        private Bgs.Protocol.Account.V1.GameLevelInfo gameLevelInfo_;
        public Bgs.Protocol.Account.V1.GameLevelInfo GameLevelInfo
        {
            get { return gameLevelInfo_; }
            set
            {
                gameLevelInfo_ = value;
            }
        }

        /// <summary>Field number for the "game_time_info" field.</summary>
        public const int GameTimeInfoFieldNumber = 2;
        private Bgs.Protocol.Account.V1.GameTimeInfo gameTimeInfo_;
        public Bgs.Protocol.Account.V1.GameTimeInfo GameTimeInfo
        {
            get { return gameTimeInfo_; }
            set
            {
                gameTimeInfo_ = value;
            }
        }

        /// <summary>Field number for the "game_status" field.</summary>
        public const int GameStatusFieldNumber = 3;
        private Bgs.Protocol.Account.V1.GameStatus gameStatus_;
        public Bgs.Protocol.Account.V1.GameStatus GameStatus
        {
            get { return gameStatus_; }
            set
            {
                gameStatus_ = value;
            }
        }

        /// <summary>Field number for the "raf_info" field.</summary>
        public const int RafInfoFieldNumber = 4;
        private Bgs.Protocol.Account.V1.RAFInfo rafInfo_;
        public Bgs.Protocol.Account.V1.RAFInfo RafInfo
        {
            get { return rafInfo_; }
            set
            {
                rafInfo_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountState);
        }

        public bool Equals(GameAccountState other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(GameLevelInfo, other.GameLevelInfo)) return false;
            if (!object.Equals(GameTimeInfo, other.GameTimeInfo)) return false;
            if (!object.Equals(GameStatus, other.GameStatus)) return false;
            if (!object.Equals(RafInfo, other.RafInfo)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (gameLevelInfo_ != null) hash ^= GameLevelInfo.GetHashCode();
            if (gameTimeInfo_ != null) hash ^= GameTimeInfo.GetHashCode();
            if (gameStatus_ != null) hash ^= GameStatus.GetHashCode();
            if (rafInfo_ != null) hash ^= RafInfo.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (gameLevelInfo_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(GameLevelInfo);
            }
            if (gameTimeInfo_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(GameTimeInfo);
            }
            if (gameStatus_ != null)
            {
                output.WriteRawTag(26);
                output.WriteMessage(GameStatus);
            }
            if (rafInfo_ != null)
            {
                output.WriteRawTag(34);
                output.WriteMessage(RafInfo);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (gameLevelInfo_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameLevelInfo);
            }
            if (gameTimeInfo_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameTimeInfo);
            }
            if (gameStatus_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameStatus);
            }
            if (rafInfo_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(RafInfo);
            }
            return size;
        }

        public void MergeFrom(GameAccountState other)
        {
            if (other == null)
            {
                return;
            }
            if (other.gameLevelInfo_ != null)
            {
                if (gameLevelInfo_ == null)
                {
                    gameLevelInfo_ = new Bgs.Protocol.Account.V1.GameLevelInfo();
                }
                GameLevelInfo.MergeFrom(other.GameLevelInfo);
            }
            if (other.gameTimeInfo_ != null)
            {
                if (gameTimeInfo_ == null)
                {
                    gameTimeInfo_ = new Bgs.Protocol.Account.V1.GameTimeInfo();
                }
                GameTimeInfo.MergeFrom(other.GameTimeInfo);
            }
            if (other.gameStatus_ != null)
            {
                if (gameStatus_ == null)
                {
                    gameStatus_ = new Bgs.Protocol.Account.V1.GameStatus();
                }
                GameStatus.MergeFrom(other.GameStatus);
            }
            if (other.rafInfo_ != null)
            {
                if (rafInfo_ == null)
                {
                    rafInfo_ = new Bgs.Protocol.Account.V1.RAFInfo();
                }
                RafInfo.MergeFrom(other.RafInfo);
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (gameLevelInfo_ == null)
                            {
                                gameLevelInfo_ = new Bgs.Protocol.Account.V1.GameLevelInfo();
                            }
                            input.ReadMessage(gameLevelInfo_);
                            break;
                        }
                    case 18:
                        {
                            if (gameTimeInfo_ == null)
                            {
                                gameTimeInfo_ = new Bgs.Protocol.Account.V1.GameTimeInfo();
                            }
                            input.ReadMessage(gameTimeInfo_);
                            break;
                        }
                    case 26:
                        {
                            if (gameStatus_ == null)
                            {
                                gameStatus_ = new Bgs.Protocol.Account.V1.GameStatus();
                            }
                            input.ReadMessage(gameStatus_);
                            break;
                        }
                    case 34:
                        {
                            if (rafInfo_ == null)
                            {
                                rafInfo_ = new Bgs.Protocol.Account.V1.RAFInfo();
                            }
                            input.ReadMessage(rafInfo_);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class GameAccountStateTagged : pb::IMessage<GameAccountStateTagged>
    {
        private static readonly pb::MessageParser<GameAccountStateTagged> _parser = new pb::MessageParser<GameAccountStateTagged>(() => new GameAccountStateTagged());
        public static pb::MessageParser<GameAccountStateTagged> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[34]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public GameAccountStateTagged()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public GameAccountStateTagged(GameAccountStateTagged other) : this()
        {
            GameAccountState = other.gameAccountState_ != null ? other.GameAccountState.Clone() : null;
            GameAccountTags = other.gameAccountTags_ != null ? other.GameAccountTags.Clone() : null;
        }

        public GameAccountStateTagged Clone()
        {
            return new GameAccountStateTagged(this);
        }

        /// <summary>Field number for the "game_account_state" field.</summary>
        public const int GameAccountStateFieldNumber = 1;
        private Bgs.Protocol.Account.V1.GameAccountState gameAccountState_;
        public Bgs.Protocol.Account.V1.GameAccountState GameAccountState
        {
            get { return gameAccountState_; }
            set
            {
                gameAccountState_ = value;
            }
        }

        /// <summary>Field number for the "game_account_tags" field.</summary>
        public const int GameAccountTagsFieldNumber = 2;
        private Bgs.Protocol.Account.V1.GameAccountFieldTags gameAccountTags_;
        public Bgs.Protocol.Account.V1.GameAccountFieldTags GameAccountTags
        {
            get { return gameAccountTags_; }
            set
            {
                gameAccountTags_ = value;
            }
        }

        public override bool Equals(object other)
        {
            return Equals(other as GameAccountStateTagged);
        }

        public bool Equals(GameAccountStateTagged other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(GameAccountState, other.GameAccountState)) return false;
            if (!object.Equals(GameAccountTags, other.GameAccountTags)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (gameAccountState_ != null) hash ^= GameAccountState.GetHashCode();
            if (gameAccountTags_ != null) hash ^= GameAccountTags.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (gameAccountState_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(GameAccountState);
            }
            if (gameAccountTags_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(GameAccountTags);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (gameAccountState_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccountState);
            }
            if (gameAccountTags_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(GameAccountTags);
            }
            return size;
        }

        public void MergeFrom(GameAccountStateTagged other)
        {
            if (other == null)
            {
                return;
            }
            if (other.gameAccountState_ != null)
            {
                if (gameAccountState_ == null)
                {
                    gameAccountState_ = new Bgs.Protocol.Account.V1.GameAccountState();
                }
                GameAccountState.MergeFrom(other.GameAccountState);
            }
            if (other.gameAccountTags_ != null)
            {
                if (gameAccountTags_ == null)
                {
                    gameAccountTags_ = new Bgs.Protocol.Account.V1.GameAccountFieldTags();
                }
                GameAccountTags.MergeFrom(other.GameAccountTags);
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (gameAccountState_ == null)
                            {
                                gameAccountState_ = new Bgs.Protocol.Account.V1.GameAccountState();
                            }
                            input.ReadMessage(gameAccountState_);
                            break;
                        }
                    case 18:
                        {
                            if (gameAccountTags_ == null)
                            {
                                gameAccountTags_ = new Bgs.Protocol.Account.V1.GameAccountFieldTags();
                            }
                            input.ReadMessage(gameAccountTags_);
                            break;
                        }
                }
            }
        }

    }

    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class AuthorizedData : pb::IMessage<AuthorizedData>
    {
        private static readonly pb::MessageParser<AuthorizedData> _parser = new pb::MessageParser<AuthorizedData>(() => new AuthorizedData());
        public static pb::MessageParser<AuthorizedData> Parser { get { return _parser; } }

        public static pbr::MessageDescriptor Descriptor
        {
            get { return Bgs.Protocol.Account.V1.AccountTypesReflection.Descriptor.MessageTypes[35]; }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public AuthorizedData()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public AuthorizedData(AuthorizedData other) : this()
        {
            data_ = other.data_;
            license_ = other.license_.Clone();
        }

        public AuthorizedData Clone()
        {
            return new AuthorizedData(this);
        }

        /// <summary>Field number for the "data" field.</summary>
        public const int DataFieldNumber = 1;
        private string data_ = "";
        public string Data
        {
            get { return data_; }
            set
            {
                data_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

        /// <summary>Field number for the "license" field.</summary>
        public const int LicenseFieldNumber = 2;
        private static readonly pb::FieldCodec<uint> _repeated_license_codec
            = pb::FieldCodec.ForUInt32(18);
        private readonly pbc::RepeatedField<uint> license_ = new pbc::RepeatedField<uint>();
        public pbc::RepeatedField<uint> License
        {
            get { return license_; }
        }

        public override bool Equals(object other)
        {
            return Equals(other as AuthorizedData);
        }

        public bool Equals(AuthorizedData other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Data != other.Data) return false;
            if (!license_.Equals(other.license_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Data.Length != 0) hash ^= Data.GetHashCode();
            hash ^= license_.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Data.Length != 0)
            {
                output.WriteRawTag(10);
                output.WriteString(Data);
            }
            license_.WriteTo(output, _repeated_license_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Data.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(Data);
            }
            size += license_.CalculateSize(_repeated_license_codec);
            return size;
        }

        public void MergeFrom(AuthorizedData other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Data.Length != 0)
            {
                Data = other.Data;
            }
            license_.Add(other.license_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            Data = input.ReadString();
                            break;
                        }
                    case 18:
                    case 16:
                        {
                            license_.AddEntriesFrom(input, _repeated_license_codec);
                            break;
                        }
                }
            }
        }

    }

    #endregion
}

#endregion Designer generated code
