// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: bgs/low/pb/client/connection_service.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.Connection.V1
{

    /// <summary>Holder for reflection information generated from bgs/low/pb/client/connection_service.proto</summary>
    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public static partial class ConnectionServiceReflection
    {

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

        static ConnectionServiceReflection()
        {
            byte[] descriptorData = System.Convert.FromBase64String(
                string.Concat(
                  "CipiZ3MvbG93L3BiL2NsaWVudC9jb25uZWN0aW9uX3NlcnZpY2UucHJvdG8S",
                  "GmJncy5wcm90b2NvbC5jb25uZWN0aW9uLnYxGixiZ3MvbG93L3BiL2NsaWVu",
                  "dC9jb250ZW50X2hhbmRsZV90eXBlcy5wcm90bxohYmdzL2xvdy9wYi9jbGll",
                  "bnQvcnBjX3R5cGVzLnByb3RvIpUBCg5Db25uZWN0UmVxdWVzdBIqCgljbGll",
                  "bnRfaWQYASABKAsyFy5iZ3MucHJvdG9jb2wuUHJvY2Vzc0lkEj0KDGJpbmRf",
                  "cmVxdWVzdBgCIAEoCzInLmJncy5wcm90b2NvbC5jb25uZWN0aW9uLnYxLkJp",
                  "bmRSZXF1ZXN0EhgKEHVzZV9iaW5kbGVzc19ycGMYAyABKAgiVwogQ29ubmVj",
                  "dGlvbk1ldGVyaW5nQ29udGVudEhhbmRsZXMSMwoOY29udGVudF9oYW5kbGUY",
                  "ASADKAsyGy5iZ3MucHJvdG9jb2wuQ29udGVudEhhbmRsZSKtAwoPQ29ubmVj",
                  "dFJlc3BvbnNlEioKCXNlcnZlcl9pZBgBIAEoCzIXLmJncy5wcm90b2NvbC5Q",
                  "cm9jZXNzSWQSKgoJY2xpZW50X2lkGAIgASgLMhcuYmdzLnByb3RvY29sLlBy",
                  "b2Nlc3NJZBITCgtiaW5kX3Jlc3VsdBgDIAEoDRI/Cg1iaW5kX3Jlc3BvbnNl",
                  "GAQgASgLMiguYmdzLnByb3RvY29sLmNvbm5lY3Rpb24udjEuQmluZFJlc3Bv",
                  "bnNlEloKFGNvbnRlbnRfaGFuZGxlX2FycmF5GAUgASgLMjwuYmdzLnByb3Rv",
                  "Y29sLmNvbm5lY3Rpb24udjEuQ29ubmVjdGlvbk1ldGVyaW5nQ29udGVudEhh",
                  "bmRsZXMSEwoLc2VydmVyX3RpbWUYBiABKAQSGAoQdXNlX2JpbmRsZXNzX3Jw",
                  "YxgHIAEoCBJhChtiaW5hcnlfY29udGVudF9oYW5kbGVfYXJyYXkYCCABKAsy",
                  "PC5iZ3MucHJvdG9jb2wuY29ubmVjdGlvbi52MS5Db25uZWN0aW9uTWV0ZXJp",
                  "bmdDb250ZW50SGFuZGxlcyIoCgxCb3VuZFNlcnZpY2USDAoEaGFzaBgBIAEo",
                  "BxIKCgJpZBgCIAEoDSKYAgoLQmluZFJlcXVlc3QSLgogZGVwcmVjYXRlZF9p",
                  "bXBvcnRlZF9zZXJ2aWNlX2hhc2gYASADKAdCBBABGAESUQobZGVwcmVjYXRl",
                  "ZF9leHBvcnRlZF9zZXJ2aWNlGAIgAygLMiguYmdzLnByb3RvY29sLmNvbm5l",
                  "Y3Rpb24udjEuQm91bmRTZXJ2aWNlQgIYARJCChBleHBvcnRlZF9zZXJ2aWNl",
                  "GAMgAygLMiguYmdzLnByb3RvY29sLmNvbm5lY3Rpb24udjEuQm91bmRTZXJ2",
                  "aWNlEkIKEGltcG9ydGVkX3NlcnZpY2UYBCADKAsyKC5iZ3MucHJvdG9jb2wu",
                  "Y29ubmVjdGlvbi52MS5Cb3VuZFNlcnZpY2UiMQoMQmluZFJlc3BvbnNlEiEK",
                  "E2ltcG9ydGVkX3NlcnZpY2VfaWQYASADKA1CBBABGAEiQgoLRWNob1JlcXVl",
                  "c3QSDAoEdGltZRgBIAEoBhIUCgxuZXR3b3JrX29ubHkYAiABKAgSDwoHcGF5",
                  "bG9hZBgDIAEoDCItCgxFY2hvUmVzcG9uc2USDAoEdGltZRgBIAEoBhIPCgdw",
                  "YXlsb2FkGAIgASgMIicKEURpc2Nvbm5lY3RSZXF1ZXN0EhIKCmVycm9yX2Nv",
                  "ZGUYASABKA0iPAoWRGlzY29ubmVjdE5vdGlmaWNhdGlvbhISCgplcnJvcl9j",
                  "b2RlGAEgASgNEg4KBnJlYXNvbhgCIAEoCSIQCg5FbmNyeXB0UmVxdWVzdDKD",
                  "BQoRQ29ubmVjdGlvblNlcnZpY2USYgoHQ29ubmVjdBIqLmJncy5wcm90b2Nv",
                  "bC5jb25uZWN0aW9uLnYxLkNvbm5lY3RSZXF1ZXN0GisuYmdzLnByb3RvY29s",
                  "LmNvbm5lY3Rpb24udjEuQ29ubmVjdFJlc3BvbnNlEl4KBEJpbmQSJy5iZ3Mu",
                  "cHJvdG9jb2wuY29ubmVjdGlvbi52MS5CaW5kUmVxdWVzdBooLmJncy5wcm90",
                  "b2NvbC5jb25uZWN0aW9uLnYxLkJpbmRSZXNwb25zZSIDiAIBElkKBEVjaG8S",
                  "Jy5iZ3MucHJvdG9jb2wuY29ubmVjdGlvbi52MS5FY2hvUmVxdWVzdBooLmJn",
                  "cy5wcm90b2NvbC5jb25uZWN0aW9uLnYxLkVjaG9SZXNwb25zZRJgCg9Gb3Jj",
                  "ZURpc2Nvbm5lY3QSMi5iZ3MucHJvdG9jb2wuY29ubmVjdGlvbi52MS5EaXNj",
                  "b25uZWN0Tm90aWZpY2F0aW9uGhkuYmdzLnByb3RvY29sLk5PX1JFU1BPTlNF",
                  "EjwKCUtlZXBBbGl2ZRIULmJncy5wcm90b2NvbC5Ob0RhdGEaGS5iZ3MucHJv",
                  "dG9jb2wuTk9fUkVTUE9OU0USUAoHRW5jcnlwdBIqLmJncy5wcm90b2NvbC5j",
                  "b25uZWN0aW9uLnYxLkVuY3J5cHRSZXF1ZXN0GhQuYmdzLnByb3RvY29sLk5v",
                  "RGF0YSIDiAIBEl0KEVJlcXVlc3REaXNjb25uZWN0Ei0uYmdzLnByb3RvY29s",
                  "LmNvbm5lY3Rpb24udjEuRGlzY29ubmVjdFJlcXVlc3QaGS5iZ3MucHJvdG9j",
                  "b2wuTk9fUkVTUE9OU0VCPQobYm5ldC5wcm90b2NvbC5jb25uZWN0aW9uLnYx",
                  "QhZDb25uZWN0aW9uU2VydmljZVByb3RvSAKAAQCIAQFiBnByb3RvMw=="));
            descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
                new pbr::FileDescriptor[] { Bgs.Protocol.ContentHandleTypesReflection.Descriptor, Bgs.Protocol.RpcTypesReflection.Descriptor, },
                new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.ConnectRequest), Bgs.Protocol.Connection.V1.ConnectRequest.Parser, new[]{ "ClientId", "BindRequest", "UseBindlessRpc" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles), Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles.Parser, new[]{ "ContentHandle" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.ConnectResponse), Bgs.Protocol.Connection.V1.ConnectResponse.Parser, new[]{ "ServerId", "ClientId", "BindResult", "BindResponse", "ContentHandleArray", "ServerTime", "UseBindlessRpc", "BinaryContentHandleArray" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.BoundService), Bgs.Protocol.Connection.V1.BoundService.Parser, new[]{ "Hash", "Id" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.BindRequest), Bgs.Protocol.Connection.V1.BindRequest.Parser, new[]{ "DeprecatedImportedServiceHash", "DeprecatedExportedService", "ExportedService", "ImportedService" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.BindResponse), Bgs.Protocol.Connection.V1.BindResponse.Parser, new[]{ "ImportedServiceId" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.EchoRequest), Bgs.Protocol.Connection.V1.EchoRequest.Parser, new[]{ "Time", "NetworkOnly", "Payload" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.EchoResponse), Bgs.Protocol.Connection.V1.EchoResponse.Parser, new[]{ "Time", "Payload" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.DisconnectRequest), Bgs.Protocol.Connection.V1.DisconnectRequest.Parser, new[]{ "ErrorCode" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.DisconnectNotification), Bgs.Protocol.Connection.V1.DisconnectNotification.Parser, new[]{ "ErrorCode", "Reason" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(Bgs.Protocol.Connection.V1.EncryptRequest), Bgs.Protocol.Connection.V1.EncryptRequest.Parser, null, null, null, null)
                }));
        }
        #endregion

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

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

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

        public ConnectRequest()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public ConnectRequest(ConnectRequest other) : this()
        {
            ClientId = other.clientId_ != null ? other.ClientId.Clone() : null;
            BindRequest = other.bindRequest_ != null ? other.BindRequest.Clone() : null;
            useBindlessRpc_ = other.useBindlessRpc_;
        }

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

        /// <summary>Field number for the "client_id" field.</summary>
        public const int ClientIdFieldNumber = 1;
        private Bgs.Protocol.ProcessId clientId_;
        public Bgs.Protocol.ProcessId ClientId
        {
            get { return clientId_; }
            set
            {
                clientId_ = value;
            }
        }

        /// <summary>Field number for the "bind_request" field.</summary>
        public const int BindRequestFieldNumber = 2;
        private Bgs.Protocol.Connection.V1.BindRequest bindRequest_;
        public Bgs.Protocol.Connection.V1.BindRequest BindRequest
        {
            get { return bindRequest_; }
            set
            {
                bindRequest_ = value;
            }
        }

        /// <summary>Field number for the "use_bindless_rpc" field.</summary>
        public const int UseBindlessRpcFieldNumber = 3;
        private bool useBindlessRpc_;
        public bool UseBindlessRpc
        {
            get { return useBindlessRpc_; }
            set
            {
                useBindlessRpc_ = value;
            }
        }

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

        public bool Equals(ConnectRequest other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(ClientId, other.ClientId)) return false;
            if (!object.Equals(BindRequest, other.BindRequest)) return false;
            if (UseBindlessRpc != other.UseBindlessRpc) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (clientId_ != null) hash ^= ClientId.GetHashCode();
            if (bindRequest_ != null) hash ^= BindRequest.GetHashCode();
            if (UseBindlessRpc != false) hash ^= UseBindlessRpc.GetHashCode();
            return hash;
        }

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (clientId_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(ClientId);
            }
            if (bindRequest_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(BindRequest);
            }
            if (UseBindlessRpc != false)
            {
                output.WriteRawTag(24);
                output.WriteBool(UseBindlessRpc);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (clientId_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClientId);
            }
            if (bindRequest_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(BindRequest);
            }
            if (UseBindlessRpc != false)
            {
                size += 1 + 1;
            }
            return size;
        }

        public void MergeFrom(ConnectRequest other)
        {
            if (other == null)
            {
                return;
            }
            if (other.clientId_ != null)
            {
                if (clientId_ == null)
                {
                    clientId_ = new Bgs.Protocol.ProcessId();
                }
                ClientId.MergeFrom(other.ClientId);
            }
            if (other.bindRequest_ != null)
            {
                if (bindRequest_ == null)
                {
                    bindRequest_ = new Bgs.Protocol.Connection.V1.BindRequest();
                }
                BindRequest.MergeFrom(other.BindRequest);
            }
            if (other.UseBindlessRpc != false)
            {
                UseBindlessRpc = other.UseBindlessRpc;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (clientId_ == null)
                            {
                                clientId_ = new Bgs.Protocol.ProcessId();
                            }
                            input.ReadMessage(clientId_);
                            break;
                        }
                    case 18:
                        {
                            if (bindRequest_ == null)
                            {
                                bindRequest_ = new Bgs.Protocol.Connection.V1.BindRequest();
                            }
                            input.ReadMessage(bindRequest_);
                            break;
                        }
                    case 24:
                        {
                            UseBindlessRpc = input.ReadBool();
                            break;
                        }
                }
            }
        }

    }

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

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

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

        public ConnectionMeteringContentHandles()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public ConnectionMeteringContentHandles(ConnectionMeteringContentHandles other) : this()
        {
            contentHandle_ = other.contentHandle_.Clone();
        }

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

        /// <summary>Field number for the "content_handle" field.</summary>
        public const int ContentHandleFieldNumber = 1;
        private static readonly pb::FieldCodec<Bgs.Protocol.ContentHandle> _repeated_contentHandle_codec
            = pb::FieldCodec.ForMessage(10, Bgs.Protocol.ContentHandle.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.ContentHandle> contentHandle_ = new pbc::RepeatedField<Bgs.Protocol.ContentHandle>();
        public pbc::RepeatedField<Bgs.Protocol.ContentHandle> ContentHandle
        {
            get { return contentHandle_; }
        }

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

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

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

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            contentHandle_.WriteTo(output, _repeated_contentHandle_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            size += contentHandle_.CalculateSize(_repeated_contentHandle_codec);
            return size;
        }

        public void MergeFrom(ConnectionMeteringContentHandles other)
        {
            if (other == null)
            {
                return;
            }
            contentHandle_.Add(other.contentHandle_);
        }

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

    }

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

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

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

        public ConnectResponse()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public ConnectResponse(ConnectResponse other) : this()
        {
            ServerId = other.serverId_ != null ? other.ServerId.Clone() : null;
            ClientId = other.clientId_ != null ? other.ClientId.Clone() : null;
            bindResult_ = other.bindResult_;
            BindResponse = other.bindResponse_ != null ? other.BindResponse.Clone() : null;
            ContentHandleArray = other.contentHandleArray_ != null ? other.ContentHandleArray.Clone() : null;
            serverTime_ = other.serverTime_;
            useBindlessRpc_ = other.useBindlessRpc_;
            BinaryContentHandleArray = other.binaryContentHandleArray_ != null ? other.BinaryContentHandleArray.Clone() : null;
        }

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

        /// <summary>Field number for the "server_id" field.</summary>
        public const int ServerIdFieldNumber = 1;
        private Bgs.Protocol.ProcessId serverId_;
        public Bgs.Protocol.ProcessId ServerId
        {
            get { return serverId_; }
            set
            {
                serverId_ = value;
            }
        }

        /// <summary>Field number for the "client_id" field.</summary>
        public const int ClientIdFieldNumber = 2;
        private Bgs.Protocol.ProcessId clientId_;
        public Bgs.Protocol.ProcessId ClientId
        {
            get { return clientId_; }
            set
            {
                clientId_ = value;
            }
        }

        /// <summary>Field number for the "bind_result" field.</summary>
        public const int BindResultFieldNumber = 3;
        private uint bindResult_;
        public uint BindResult
        {
            get { return bindResult_; }
            set
            {
                bindResult_ = value;
            }
        }

        /// <summary>Field number for the "bind_response" field.</summary>
        public const int BindResponseFieldNumber = 4;
        private Bgs.Protocol.Connection.V1.BindResponse bindResponse_;
        public Bgs.Protocol.Connection.V1.BindResponse BindResponse
        {
            get { return bindResponse_; }
            set
            {
                bindResponse_ = value;
            }
        }

        /// <summary>Field number for the "content_handle_array" field.</summary>
        public const int ContentHandleArrayFieldNumber = 5;
        private Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles contentHandleArray_;
        public Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles ContentHandleArray
        {
            get { return contentHandleArray_; }
            set
            {
                contentHandleArray_ = value;
            }
        }

        /// <summary>Field number for the "server_time" field.</summary>
        public const int ServerTimeFieldNumber = 6;
        private ulong serverTime_;
        public ulong ServerTime
        {
            get { return serverTime_; }
            set
            {
                serverTime_ = value;
            }
        }

        /// <summary>Field number for the "use_bindless_rpc" field.</summary>
        public const int UseBindlessRpcFieldNumber = 7;
        private bool useBindlessRpc_;
        public bool UseBindlessRpc
        {
            get { return useBindlessRpc_; }
            set
            {
                useBindlessRpc_ = value;
            }
        }

        /// <summary>Field number for the "binary_content_handle_array" field.</summary>
        public const int BinaryContentHandleArrayFieldNumber = 8;
        private Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles binaryContentHandleArray_;
        public Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles BinaryContentHandleArray
        {
            get { return binaryContentHandleArray_; }
            set
            {
                binaryContentHandleArray_ = value;
            }
        }

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

        public bool Equals(ConnectResponse other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!object.Equals(ServerId, other.ServerId)) return false;
            if (!object.Equals(ClientId, other.ClientId)) return false;
            if (BindResult != other.BindResult) return false;
            if (!object.Equals(BindResponse, other.BindResponse)) return false;
            if (!object.Equals(ContentHandleArray, other.ContentHandleArray)) return false;
            if (ServerTime != other.ServerTime) return false;
            if (UseBindlessRpc != other.UseBindlessRpc) return false;
            if (!object.Equals(BinaryContentHandleArray, other.BinaryContentHandleArray)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (serverId_ != null) hash ^= ServerId.GetHashCode();
            if (clientId_ != null) hash ^= ClientId.GetHashCode();
            if (BindResult != 0) hash ^= BindResult.GetHashCode();
            if (bindResponse_ != null) hash ^= BindResponse.GetHashCode();
            if (contentHandleArray_ != null) hash ^= ContentHandleArray.GetHashCode();
            if (ServerTime != 0UL) hash ^= ServerTime.GetHashCode();
            if (UseBindlessRpc != false) hash ^= UseBindlessRpc.GetHashCode();
            if (binaryContentHandleArray_ != null) hash ^= BinaryContentHandleArray.GetHashCode();
            return hash;
        }

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (serverId_ != null)
            {
                output.WriteRawTag(10);
                output.WriteMessage(ServerId);
            }
            if (clientId_ != null)
            {
                output.WriteRawTag(18);
                output.WriteMessage(ClientId);
            }
            if (BindResult != 0)
            {
                output.WriteRawTag(24);
                output.WriteUInt32(BindResult);
            }
            if (bindResponse_ != null)
            {
                output.WriteRawTag(34);
                output.WriteMessage(BindResponse);
            }
            if (contentHandleArray_ != null)
            {
                output.WriteRawTag(42);
                output.WriteMessage(ContentHandleArray);
            }
            if (ServerTime != 0UL)
            {
                output.WriteRawTag(48);
                output.WriteUInt64(ServerTime);
            }
            if (UseBindlessRpc != false)
            {
                output.WriteRawTag(56);
                output.WriteBool(UseBindlessRpc);
            }
            if (binaryContentHandleArray_ != null)
            {
                output.WriteRawTag(66);
                output.WriteMessage(BinaryContentHandleArray);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (serverId_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(ServerId);
            }
            if (clientId_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClientId);
            }
            if (BindResult != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt32Size(BindResult);
            }
            if (bindResponse_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(BindResponse);
            }
            if (contentHandleArray_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(ContentHandleArray);
            }
            if (ServerTime != 0UL)
            {
                size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ServerTime);
            }
            if (UseBindlessRpc != false)
            {
                size += 1 + 1;
            }
            if (binaryContentHandleArray_ != null)
            {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(BinaryContentHandleArray);
            }
            return size;
        }

        public void MergeFrom(ConnectResponse other)
        {
            if (other == null)
            {
                return;
            }
            if (other.serverId_ != null)
            {
                if (serverId_ == null)
                {
                    serverId_ = new Bgs.Protocol.ProcessId();
                }
                ServerId.MergeFrom(other.ServerId);
            }
            if (other.clientId_ != null)
            {
                if (clientId_ == null)
                {
                    clientId_ = new Bgs.Protocol.ProcessId();
                }
                ClientId.MergeFrom(other.ClientId);
            }
            if (other.BindResult != 0)
            {
                BindResult = other.BindResult;
            }
            if (other.bindResponse_ != null)
            {
                if (bindResponse_ == null)
                {
                    bindResponse_ = new Bgs.Protocol.Connection.V1.BindResponse();
                }
                BindResponse.MergeFrom(other.BindResponse);
            }
            if (other.contentHandleArray_ != null)
            {
                if (contentHandleArray_ == null)
                {
                    contentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
                }
                ContentHandleArray.MergeFrom(other.ContentHandleArray);
            }
            if (other.ServerTime != 0UL)
            {
                ServerTime = other.ServerTime;
            }
            if (other.UseBindlessRpc != false)
            {
                UseBindlessRpc = other.UseBindlessRpc;
            }
            if (other.binaryContentHandleArray_ != null)
            {
                if (binaryContentHandleArray_ == null)
                {
                    binaryContentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
                }
                BinaryContentHandleArray.MergeFrom(other.BinaryContentHandleArray);
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                        {
                            if (serverId_ == null)
                            {
                                serverId_ = new Bgs.Protocol.ProcessId();
                            }
                            input.ReadMessage(serverId_);
                            break;
                        }
                    case 18:
                        {
                            if (clientId_ == null)
                            {
                                clientId_ = new Bgs.Protocol.ProcessId();
                            }
                            input.ReadMessage(clientId_);
                            break;
                        }
                    case 24:
                        {
                            BindResult = input.ReadUInt32();
                            break;
                        }
                    case 34:
                        {
                            if (bindResponse_ == null)
                            {
                                bindResponse_ = new Bgs.Protocol.Connection.V1.BindResponse();
                            }
                            input.ReadMessage(bindResponse_);
                            break;
                        }
                    case 42:
                        {
                            if (contentHandleArray_ == null)
                            {
                                contentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
                            }
                            input.ReadMessage(contentHandleArray_);
                            break;
                        }
                    case 48:
                        {
                            ServerTime = input.ReadUInt64();
                            break;
                        }
                    case 56:
                        {
                            UseBindlessRpc = input.ReadBool();
                            break;
                        }
                    case 66:
                        {
                            if (binaryContentHandleArray_ == null)
                            {
                                binaryContentHandleArray_ = new Bgs.Protocol.Connection.V1.ConnectionMeteringContentHandles();
                            }
                            input.ReadMessage(binaryContentHandleArray_);
                            break;
                        }
                }
            }
        }

    }

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

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

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

        public BoundService()
        {
            OnConstruction();
        }

        partial void OnConstruction();

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

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

        /// <summary>Field number for the "hash" field.</summary>
        public const int HashFieldNumber = 1;
        private uint hash_;
        public uint Hash
        {
            get { return hash_; }
            set
            {
                hash_ = value;
            }
        }

        /// <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;
            }
        }

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

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

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

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

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

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

        public void MergeFrom(BoundService other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Hash != 0)
            {
                Hash = other.Hash;
            }
            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:
                        {
                            Hash = input.ReadFixed32();
                            break;
                        }
                    case 16:
                        {
                            Id = input.ReadUInt32();
                            break;
                        }
                }
            }
        }

    }

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

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

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

        public BindRequest()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public BindRequest(BindRequest other) : this()
        {
            deprecatedImportedServiceHash_ = other.deprecatedImportedServiceHash_.Clone();
            deprecatedExportedService_ = other.deprecatedExportedService_.Clone();
            exportedService_ = other.exportedService_.Clone();
            importedService_ = other.importedService_.Clone();
        }

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

        /// <summary>Field number for the "deprecated_imported_service_hash" field.</summary>
        public const int DeprecatedImportedServiceHashFieldNumber = 1;
        private static readonly pb::FieldCodec<uint> _repeated_deprecatedImportedServiceHash_codec
            = pb::FieldCodec.ForFixed32(10);
        private readonly pbc::RepeatedField<uint> deprecatedImportedServiceHash_ = new pbc::RepeatedField<uint>();
        [System.ObsoleteAttribute()]
        public pbc::RepeatedField<uint> DeprecatedImportedServiceHash
        {
            get { return deprecatedImportedServiceHash_; }
        }

        /// <summary>Field number for the "deprecated_exported_service" field.</summary>
        public const int DeprecatedExportedServiceFieldNumber = 2;
        private static readonly pb::FieldCodec<Bgs.Protocol.Connection.V1.BoundService> _repeated_deprecatedExportedService_codec
            = pb::FieldCodec.ForMessage(18, Bgs.Protocol.Connection.V1.BoundService.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> deprecatedExportedService_ = new pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService>();
        [System.ObsoleteAttribute()]
        public pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> DeprecatedExportedService
        {
            get { return deprecatedExportedService_; }
        }

        /// <summary>Field number for the "exported_service" field.</summary>
        public const int ExportedServiceFieldNumber = 3;
        private static readonly pb::FieldCodec<Bgs.Protocol.Connection.V1.BoundService> _repeated_exportedService_codec
            = pb::FieldCodec.ForMessage(26, Bgs.Protocol.Connection.V1.BoundService.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> exportedService_ = new pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService>();
        public pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> ExportedService
        {
            get { return exportedService_; }
        }

        /// <summary>Field number for the "imported_service" field.</summary>
        public const int ImportedServiceFieldNumber = 4;
        private static readonly pb::FieldCodec<Bgs.Protocol.Connection.V1.BoundService> _repeated_importedService_codec
            = pb::FieldCodec.ForMessage(34, Bgs.Protocol.Connection.V1.BoundService.Parser);
        private readonly pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> importedService_ = new pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService>();
        public pbc::RepeatedField<Bgs.Protocol.Connection.V1.BoundService> ImportedService
        {
            get { return importedService_; }
        }

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

        public bool Equals(BindRequest other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (!deprecatedImportedServiceHash_.Equals(other.deprecatedImportedServiceHash_)) return false;
            if (!deprecatedExportedService_.Equals(other.deprecatedExportedService_)) return false;
            if (!exportedService_.Equals(other.exportedService_)) return false;
            if (!importedService_.Equals(other.importedService_)) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            hash ^= deprecatedImportedServiceHash_.GetHashCode();
            hash ^= deprecatedExportedService_.GetHashCode();
            hash ^= exportedService_.GetHashCode();
            hash ^= importedService_.GetHashCode();
            return hash;
        }

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            deprecatedImportedServiceHash_.WriteTo(output, _repeated_deprecatedImportedServiceHash_codec);
            deprecatedExportedService_.WriteTo(output, _repeated_deprecatedExportedService_codec);
            exportedService_.WriteTo(output, _repeated_exportedService_codec);
            importedService_.WriteTo(output, _repeated_importedService_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            size += deprecatedImportedServiceHash_.CalculateSize(_repeated_deprecatedImportedServiceHash_codec);
            size += deprecatedExportedService_.CalculateSize(_repeated_deprecatedExportedService_codec);
            size += exportedService_.CalculateSize(_repeated_exportedService_codec);
            size += importedService_.CalculateSize(_repeated_importedService_codec);
            return size;
        }

        public void MergeFrom(BindRequest other)
        {
            if (other == null)
            {
                return;
            }
            deprecatedImportedServiceHash_.Add(other.deprecatedImportedServiceHash_);
            deprecatedExportedService_.Add(other.deprecatedExportedService_);
            exportedService_.Add(other.exportedService_);
            importedService_.Add(other.importedService_);
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                    case 13:
                        {
                            deprecatedImportedServiceHash_.AddEntriesFrom(input, _repeated_deprecatedImportedServiceHash_codec);
                            break;
                        }
                    case 18:
                        {
                            deprecatedExportedService_.AddEntriesFrom(input, _repeated_deprecatedExportedService_codec);
                            break;
                        }
                    case 26:
                        {
                            exportedService_.AddEntriesFrom(input, _repeated_exportedService_codec);
                            break;
                        }
                    case 34:
                        {
                            importedService_.AddEntriesFrom(input, _repeated_importedService_codec);
                            break;
                        }
                }
            }
        }

    }

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

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

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

        public BindResponse()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public BindResponse(BindResponse other) : this()
        {
            importedServiceId_ = other.importedServiceId_.Clone();
        }

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

        /// <summary>Field number for the "imported_service_id" field.</summary>
        public const int ImportedServiceIdFieldNumber = 1;
        private static readonly pb::FieldCodec<uint> _repeated_importedServiceId_codec
            = pb::FieldCodec.ForUInt32(10);
        private readonly pbc::RepeatedField<uint> importedServiceId_ = new pbc::RepeatedField<uint>();
        [System.ObsoleteAttribute()]
        public pbc::RepeatedField<uint> ImportedServiceId
        {
            get { return importedServiceId_; }
        }

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

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

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

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            importedServiceId_.WriteTo(output, _repeated_importedServiceId_codec);
        }

        public int CalculateSize()
        {
            int size = 0;
            size += importedServiceId_.CalculateSize(_repeated_importedServiceId_codec);
            return size;
        }

        public void MergeFrom(BindResponse other)
        {
            if (other == null)
            {
                return;
            }
            importedServiceId_.Add(other.importedServiceId_);
        }

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

    }

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

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

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

        public EchoRequest()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public EchoRequest(EchoRequest other) : this()
        {
            time_ = other.time_;
            networkOnly_ = other.networkOnly_;
            payload_ = other.payload_;
        }

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

        /// <summary>Field number for the "time" field.</summary>
        public const int TimeFieldNumber = 1;
        private ulong time_;
        public ulong Time
        {
            get { return time_; }
            set
            {
                time_ = value;
            }
        }

        /// <summary>Field number for the "network_only" field.</summary>
        public const int NetworkOnlyFieldNumber = 2;
        private bool networkOnly_;
        public bool NetworkOnly
        {
            get { return networkOnly_; }
            set
            {
                networkOnly_ = value;
            }
        }

        /// <summary>Field number for the "payload" field.</summary>
        public const int PayloadFieldNumber = 3;
        private pb::ByteString payload_ = pb::ByteString.Empty;
        public pb::ByteString Payload
        {
            get { return payload_; }
            set
            {
                payload_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            }
        }

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

        public bool Equals(EchoRequest other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (Time != other.Time) return false;
            if (NetworkOnly != other.NetworkOnly) return false;
            if (Payload != other.Payload) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (Time != 0UL) hash ^= Time.GetHashCode();
            if (NetworkOnly != false) hash ^= NetworkOnly.GetHashCode();
            if (Payload.Length != 0) hash ^= Payload.GetHashCode();
            return hash;
        }

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Time != 0UL)
            {
                output.WriteRawTag(9);
                output.WriteFixed64(Time);
            }
            if (NetworkOnly != false)
            {
                output.WriteRawTag(16);
                output.WriteBool(NetworkOnly);
            }
            if (Payload.Length != 0)
            {
                output.WriteRawTag(26);
                output.WriteBytes(Payload);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (Time != 0UL)
            {
                size += 1 + 8;
            }
            if (NetworkOnly != false)
            {
                size += 1 + 1;
            }
            if (Payload.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeBytesSize(Payload);
            }
            return size;
        }

        public void MergeFrom(EchoRequest other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Time != 0UL)
            {
                Time = other.Time;
            }
            if (other.NetworkOnly != false)
            {
                NetworkOnly = other.NetworkOnly;
            }
            if (other.Payload.Length != 0)
            {
                Payload = other.Payload;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 9:
                        {
                            Time = input.ReadFixed64();
                            break;
                        }
                    case 16:
                        {
                            NetworkOnly = input.ReadBool();
                            break;
                        }
                    case 26:
                        {
                            Payload = input.ReadBytes();
                            break;
                        }
                }
            }
        }

    }

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

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

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

        public EchoResponse()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public EchoResponse(EchoResponse other) : this()
        {
            time_ = other.time_;
            payload_ = other.payload_;
        }

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

        /// <summary>Field number for the "time" field.</summary>
        public const int TimeFieldNumber = 1;
        private ulong time_;
        public ulong Time
        {
            get { return time_; }
            set
            {
                time_ = value;
            }
        }

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

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

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

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

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (Time != 0UL)
            {
                output.WriteRawTag(9);
                output.WriteFixed64(Time);
            }
            if (Payload.Length != 0)
            {
                output.WriteRawTag(18);
                output.WriteBytes(Payload);
            }
        }

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

        public void MergeFrom(EchoResponse other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Time != 0UL)
            {
                Time = other.Time;
            }
            if (other.Payload.Length != 0)
            {
                Payload = other.Payload;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 9:
                        {
                            Time = input.ReadFixed64();
                            break;
                        }
                    case 18:
                        {
                            Payload = input.ReadBytes();
                            break;
                        }
                }
            }
        }

    }

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

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

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

        public DisconnectRequest()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public DisconnectRequest(DisconnectRequest other) : this()
        {
            errorCode_ = other.errorCode_;
        }

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

        /// <summary>Field number for the "error_code" field.</summary>
        public const int ErrorCodeFieldNumber = 1;
        private uint errorCode_;
        public uint ErrorCode
        {
            get { return errorCode_; }
            set
            {
                errorCode_ = value;
            }
        }

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

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

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

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (ErrorCode != 0)
            {
                output.WriteRawTag(8);
                output.WriteUInt32(ErrorCode);
            }
        }

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

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

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

    }

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

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

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

        public DisconnectNotification()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public DisconnectNotification(DisconnectNotification other) : this()
        {
            errorCode_ = other.errorCode_;
            reason_ = other.reason_;
        }

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

        /// <summary>Field number for the "error_code" field.</summary>
        public const int ErrorCodeFieldNumber = 1;
        private uint errorCode_;
        public uint ErrorCode
        {
            get { return errorCode_; }
            set
            {
                errorCode_ = value;
            }
        }

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

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

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

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

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

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (ErrorCode != 0)
            {
                output.WriteRawTag(8);
                output.WriteUInt32(ErrorCode);
            }
            if (Reason.Length != 0)
            {
                output.WriteRawTag(18);
                output.WriteString(Reason);
            }
        }

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

        public void MergeFrom(DisconnectNotification other)
        {
            if (other == null)
            {
                return;
            }
            if (other.ErrorCode != 0)
            {
                ErrorCode = other.ErrorCode;
            }
            if (other.Reason.Length != 0)
            {
                Reason = other.Reason;
            }
        }

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

    }

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

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

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

        public EncryptRequest()
        {
            OnConstruction();
        }

        partial void OnConstruction();

        public EncryptRequest(EncryptRequest other) : this()
        {
        }

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

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

        public bool Equals(EncryptRequest other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            return true;
        }

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

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

        public void WriteTo(pb::CodedOutputStream output)
        {
        }

        public int CalculateSize()
        {
            int size = 0;
            return size;
        }

        public void MergeFrom(EncryptRequest other)
        {
            if (other == null)
            {
                return;
            }
        }

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

    }

    #endregion
}

#endregion Designer generated code