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

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Bgs.Protocol.Config {

  /// <summary>Holder for reflection information generated from bgs/low/pb/client/rpc_config.proto</summary>
  public static partial class RpcConfigReflection {

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

    static RpcConfigReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "CiJiZ3MvbG93L3BiL2NsaWVudC9ycGNfY29uZmlnLnByb3RvEhNiZ3MucHJv",
            "dG9jb2wuY29uZmlnIoIDCg9SUENNZXRob2RDb25maWcSGAoMc2VydmljZV9u",
            "YW1lGAEgASgJQgIYARIXCgttZXRob2RfbmFtZRgCIAEoCUICGAESGgoPZml4",
            "ZWRfY2FsbF9jb3N0GAMgASgNOgExEhkKEWZpeGVkX3BhY2tldF9zaXplGAQg",
            "ASgNEhsKE3ZhcmlhYmxlX211bHRpcGxpZXIYBSABKAISFQoKbXVsdGlwbGll",
            "chgGIAEoAjoBMRIYChByYXRlX2xpbWl0X2NvdW50GAcgASgNEhoKEnJhdGVf",
            "bGltaXRfc2Vjb25kcxgIIAEoDRIXCg9tYXhfcGFja2V0X3NpemUYCSABKA0S",
            "GAoQbWF4X2VuY29kZWRfc2l6ZRgKIAEoDRIPCgd0aW1lb3V0GAsgASgCEhMK",
            "C2NhcF9iYWxhbmNlGAwgASgNEhkKEWluY29tZV9wZXJfc2Vjb25kGA0gASgC",
            "EhQKDHNlcnZpY2VfaGFzaBgOIAEoDRIRCgltZXRob2RfaWQYDyABKA0iqgEK",
            "DlJQQ01ldGVyQ29uZmlnEjQKBm1ldGhvZBgBIAMoCzIkLmJncy5wcm90b2Nv",
            "bC5jb25maWcuUlBDTWV0aG9kQ29uZmlnEhwKEWluY29tZV9wZXJfc2Vjb25k",
            "GAIgASgNOgExEhcKD2luaXRpYWxfYmFsYW5jZRgDIAEoDRITCgtjYXBfYmFs",
            "YW5jZRgEIAEoDRIWCg5zdGFydHVwX3BlcmlvZBgFIAEoAg=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.Config.RPCMethodConfig), global::Bgs.Protocol.Config.RPCMethodConfig.Parser, new[]{ "ServiceName", "MethodName", "FixedCallCost", "FixedPacketSize", "VariableMultiplier", "Multiplier", "RateLimitCount", "RateLimitSeconds", "MaxPacketSize", "MaxEncodedSize", "Timeout", "CapBalance", "IncomePerSecond", "ServiceHash", "MethodId" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.Config.RPCMeterConfig), global::Bgs.Protocol.Config.RPCMeterConfig.Parser, new[]{ "Method", "IncomePerSecond", "InitialBalance", "CapBalance", "StartupPeriod" }, null, null, null, null)
          }));
    }
    #endregion

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

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Bgs.Protocol.Config.RpcConfigReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RPCMethodConfig() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RPCMethodConfig(RPCMethodConfig other) : this() {
      _hasBits0 = other._hasBits0;
      serviceName_ = other.serviceName_;
      methodName_ = other.methodName_;
      fixedCallCost_ = other.fixedCallCost_;
      fixedPacketSize_ = other.fixedPacketSize_;
      variableMultiplier_ = other.variableMultiplier_;
      multiplier_ = other.multiplier_;
      rateLimitCount_ = other.rateLimitCount_;
      rateLimitSeconds_ = other.rateLimitSeconds_;
      maxPacketSize_ = other.maxPacketSize_;
      maxEncodedSize_ = other.maxEncodedSize_;
      timeout_ = other.timeout_;
      capBalance_ = other.capBalance_;
      incomePerSecond_ = other.incomePerSecond_;
      serviceHash_ = other.serviceHash_;
      methodId_ = other.methodId_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RPCMethodConfig Clone() {
      return new RPCMethodConfig(this);
    }

    /// <summary>Field number for the "service_name" field.</summary>
    public const int ServiceNameFieldNumber = 1;
    private readonly static string ServiceNameDefaultValue = "";

    private string serviceName_;
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string ServiceName {
      get { return serviceName_ ?? ServiceNameDefaultValue; }
      set {
        serviceName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }
    /// <summary>Gets whether the "service_name" field is set</summary>
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasServiceName {
      get { return serviceName_ != null; }
    }
    /// <summary>Clears the value of the "service_name" field</summary>
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearServiceName() {
      serviceName_ = null;
    }

    /// <summary>Field number for the "method_name" field.</summary>
    public const int MethodNameFieldNumber = 2;
    private readonly static string MethodNameDefaultValue = "";

    private string methodName_;
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string MethodName {
      get { return methodName_ ?? MethodNameDefaultValue; }
      set {
        methodName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }
    /// <summary>Gets whether the "method_name" field is set</summary>
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasMethodName {
      get { return methodName_ != null; }
    }
    /// <summary>Clears the value of the "method_name" field</summary>
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearMethodName() {
      methodName_ = null;
    }

    /// <summary>Field number for the "fixed_call_cost" field.</summary>
    public const int FixedCallCostFieldNumber = 3;
    private readonly static uint FixedCallCostDefaultValue = 1;

    private uint fixedCallCost_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint FixedCallCost {
      get { if ((_hasBits0 & 1) != 0) { return fixedCallCost_; } else { return FixedCallCostDefaultValue; } }
      set {
        _hasBits0 |= 1;
        fixedCallCost_ = value;
      }
    }
    /// <summary>Gets whether the "fixed_call_cost" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasFixedCallCost {
      get { return (_hasBits0 & 1) != 0; }
    }
    /// <summary>Clears the value of the "fixed_call_cost" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearFixedCallCost() {
      _hasBits0 &= ~1;
    }

    /// <summary>Field number for the "fixed_packet_size" field.</summary>
    public const int FixedPacketSizeFieldNumber = 4;
    private readonly static uint FixedPacketSizeDefaultValue = 0;

    private uint fixedPacketSize_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint FixedPacketSize {
      get { if ((_hasBits0 & 2) != 0) { return fixedPacketSize_; } else { return FixedPacketSizeDefaultValue; } }
      set {
        _hasBits0 |= 2;
        fixedPacketSize_ = value;
      }
    }
    /// <summary>Gets whether the "fixed_packet_size" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasFixedPacketSize {
      get { return (_hasBits0 & 2) != 0; }
    }
    /// <summary>Clears the value of the "fixed_packet_size" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearFixedPacketSize() {
      _hasBits0 &= ~2;
    }

    /// <summary>Field number for the "variable_multiplier" field.</summary>
    public const int VariableMultiplierFieldNumber = 5;
    private readonly static float VariableMultiplierDefaultValue = 0F;

    private float variableMultiplier_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public float VariableMultiplier {
      get { if ((_hasBits0 & 4) != 0) { return variableMultiplier_; } else { return VariableMultiplierDefaultValue; } }
      set {
        _hasBits0 |= 4;
        variableMultiplier_ = value;
      }
    }
    /// <summary>Gets whether the "variable_multiplier" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasVariableMultiplier {
      get { return (_hasBits0 & 4) != 0; }
    }
    /// <summary>Clears the value of the "variable_multiplier" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearVariableMultiplier() {
      _hasBits0 &= ~4;
    }

    /// <summary>Field number for the "multiplier" field.</summary>
    public const int MultiplierFieldNumber = 6;
    private readonly static float MultiplierDefaultValue = 1F;

    private float multiplier_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public float Multiplier {
      get { if ((_hasBits0 & 8) != 0) { return multiplier_; } else { return MultiplierDefaultValue; } }
      set {
        _hasBits0 |= 8;
        multiplier_ = value;
      }
    }
    /// <summary>Gets whether the "multiplier" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasMultiplier {
      get { return (_hasBits0 & 8) != 0; }
    }
    /// <summary>Clears the value of the "multiplier" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearMultiplier() {
      _hasBits0 &= ~8;
    }

    /// <summary>Field number for the "rate_limit_count" field.</summary>
    public const int RateLimitCountFieldNumber = 7;
    private readonly static uint RateLimitCountDefaultValue = 0;

    private uint rateLimitCount_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint RateLimitCount {
      get { if ((_hasBits0 & 16) != 0) { return rateLimitCount_; } else { return RateLimitCountDefaultValue; } }
      set {
        _hasBits0 |= 16;
        rateLimitCount_ = value;
      }
    }
    /// <summary>Gets whether the "rate_limit_count" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasRateLimitCount {
      get { return (_hasBits0 & 16) != 0; }
    }
    /// <summary>Clears the value of the "rate_limit_count" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearRateLimitCount() {
      _hasBits0 &= ~16;
    }

    /// <summary>Field number for the "rate_limit_seconds" field.</summary>
    public const int RateLimitSecondsFieldNumber = 8;
    private readonly static uint RateLimitSecondsDefaultValue = 0;

    private uint rateLimitSeconds_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint RateLimitSeconds {
      get { if ((_hasBits0 & 32) != 0) { return rateLimitSeconds_; } else { return RateLimitSecondsDefaultValue; } }
      set {
        _hasBits0 |= 32;
        rateLimitSeconds_ = value;
      }
    }
    /// <summary>Gets whether the "rate_limit_seconds" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasRateLimitSeconds {
      get { return (_hasBits0 & 32) != 0; }
    }
    /// <summary>Clears the value of the "rate_limit_seconds" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearRateLimitSeconds() {
      _hasBits0 &= ~32;
    }

    /// <summary>Field number for the "max_packet_size" field.</summary>
    public const int MaxPacketSizeFieldNumber = 9;
    private readonly static uint MaxPacketSizeDefaultValue = 0;

    private uint maxPacketSize_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint MaxPacketSize {
      get { if ((_hasBits0 & 64) != 0) { return maxPacketSize_; } else { return MaxPacketSizeDefaultValue; } }
      set {
        _hasBits0 |= 64;
        maxPacketSize_ = value;
      }
    }
    /// <summary>Gets whether the "max_packet_size" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasMaxPacketSize {
      get { return (_hasBits0 & 64) != 0; }
    }
    /// <summary>Clears the value of the "max_packet_size" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearMaxPacketSize() {
      _hasBits0 &= ~64;
    }

    /// <summary>Field number for the "max_encoded_size" field.</summary>
    public const int MaxEncodedSizeFieldNumber = 10;
    private readonly static uint MaxEncodedSizeDefaultValue = 0;

    private uint maxEncodedSize_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint MaxEncodedSize {
      get { if ((_hasBits0 & 128) != 0) { return maxEncodedSize_; } else { return MaxEncodedSizeDefaultValue; } }
      set {
        _hasBits0 |= 128;
        maxEncodedSize_ = value;
      }
    }
    /// <summary>Gets whether the "max_encoded_size" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasMaxEncodedSize {
      get { return (_hasBits0 & 128) != 0; }
    }
    /// <summary>Clears the value of the "max_encoded_size" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearMaxEncodedSize() {
      _hasBits0 &= ~128;
    }

    /// <summary>Field number for the "timeout" field.</summary>
    public const int TimeoutFieldNumber = 11;
    private readonly static float TimeoutDefaultValue = 0F;

    private float timeout_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public float Timeout {
      get { if ((_hasBits0 & 256) != 0) { return timeout_; } else { return TimeoutDefaultValue; } }
      set {
        _hasBits0 |= 256;
        timeout_ = value;
      }
    }
    /// <summary>Gets whether the "timeout" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasTimeout {
      get { return (_hasBits0 & 256) != 0; }
    }
    /// <summary>Clears the value of the "timeout" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearTimeout() {
      _hasBits0 &= ~256;
    }

    /// <summary>Field number for the "cap_balance" field.</summary>
    public const int CapBalanceFieldNumber = 12;
    private readonly static uint CapBalanceDefaultValue = 0;

    private uint capBalance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint CapBalance {
      get { if ((_hasBits0 & 512) != 0) { return capBalance_; } else { return CapBalanceDefaultValue; } }
      set {
        _hasBits0 |= 512;
        capBalance_ = value;
      }
    }
    /// <summary>Gets whether the "cap_balance" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasCapBalance {
      get { return (_hasBits0 & 512) != 0; }
    }
    /// <summary>Clears the value of the "cap_balance" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearCapBalance() {
      _hasBits0 &= ~512;
    }

    /// <summary>Field number for the "income_per_second" field.</summary>
    public const int IncomePerSecondFieldNumber = 13;
    private readonly static float IncomePerSecondDefaultValue = 0F;

    private float incomePerSecond_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public float IncomePerSecond {
      get { if ((_hasBits0 & 1024) != 0) { return incomePerSecond_; } else { return IncomePerSecondDefaultValue; } }
      set {
        _hasBits0 |= 1024;
        incomePerSecond_ = value;
      }
    }
    /// <summary>Gets whether the "income_per_second" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasIncomePerSecond {
      get { return (_hasBits0 & 1024) != 0; }
    }
    /// <summary>Clears the value of the "income_per_second" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearIncomePerSecond() {
      _hasBits0 &= ~1024;
    }

    /// <summary>Field number for the "service_hash" field.</summary>
    public const int ServiceHashFieldNumber = 14;
    private readonly static uint ServiceHashDefaultValue = 0;

    private uint serviceHash_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint ServiceHash {
      get { if ((_hasBits0 & 2048) != 0) { return serviceHash_; } else { return ServiceHashDefaultValue; } }
      set {
        _hasBits0 |= 2048;
        serviceHash_ = value;
      }
    }
    /// <summary>Gets whether the "service_hash" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasServiceHash {
      get { return (_hasBits0 & 2048) != 0; }
    }
    /// <summary>Clears the value of the "service_hash" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearServiceHash() {
      _hasBits0 &= ~2048;
    }

    /// <summary>Field number for the "method_id" field.</summary>
    public const int MethodIdFieldNumber = 15;
    private readonly static uint MethodIdDefaultValue = 0;

    private uint methodId_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint MethodId {
      get { if ((_hasBits0 & 4096) != 0) { return methodId_; } else { return MethodIdDefaultValue; } }
      set {
        _hasBits0 |= 4096;
        methodId_ = value;
      }
    }
    /// <summary>Gets whether the "method_id" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasMethodId {
      get { return (_hasBits0 & 4096) != 0; }
    }
    /// <summary>Clears the value of the "method_id" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearMethodId() {
      _hasBits0 &= ~4096;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as RPCMethodConfig);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(RPCMethodConfig other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (ServiceName != other.ServiceName) return false;
      if (MethodName != other.MethodName) return false;
      if (FixedCallCost != other.FixedCallCost) return false;
      if (FixedPacketSize != other.FixedPacketSize) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(VariableMultiplier, other.VariableMultiplier)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Multiplier, other.Multiplier)) return false;
      if (RateLimitCount != other.RateLimitCount) return false;
      if (RateLimitSeconds != other.RateLimitSeconds) return false;
      if (MaxPacketSize != other.MaxPacketSize) return false;
      if (MaxEncodedSize != other.MaxEncodedSize) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Timeout, other.Timeout)) return false;
      if (CapBalance != other.CapBalance) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(IncomePerSecond, other.IncomePerSecond)) return false;
      if (ServiceHash != other.ServiceHash) return false;
      if (MethodId != other.MethodId) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (HasServiceName) hash ^= ServiceName.GetHashCode();
      if (HasMethodName) hash ^= MethodName.GetHashCode();
      if (HasFixedCallCost) hash ^= FixedCallCost.GetHashCode();
      if (HasFixedPacketSize) hash ^= FixedPacketSize.GetHashCode();
      if (HasVariableMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(VariableMultiplier);
      if (HasMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Multiplier);
      if (HasRateLimitCount) hash ^= RateLimitCount.GetHashCode();
      if (HasRateLimitSeconds) hash ^= RateLimitSeconds.GetHashCode();
      if (HasMaxPacketSize) hash ^= MaxPacketSize.GetHashCode();
      if (HasMaxEncodedSize) hash ^= MaxEncodedSize.GetHashCode();
      if (HasTimeout) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Timeout);
      if (HasCapBalance) hash ^= CapBalance.GetHashCode();
      if (HasIncomePerSecond) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(IncomePerSecond);
      if (HasServiceHash) hash ^= ServiceHash.GetHashCode();
      if (HasMethodId) hash ^= MethodId.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (HasServiceName) {
        output.WriteRawTag(10);
        output.WriteString(ServiceName);
      }
      if (HasMethodName) {
        output.WriteRawTag(18);
        output.WriteString(MethodName);
      }
      if (HasFixedCallCost) {
        output.WriteRawTag(24);
        output.WriteUInt32(FixedCallCost);
      }
      if (HasFixedPacketSize) {
        output.WriteRawTag(32);
        output.WriteUInt32(FixedPacketSize);
      }
      if (HasVariableMultiplier) {
        output.WriteRawTag(45);
        output.WriteFloat(VariableMultiplier);
      }
      if (HasMultiplier) {
        output.WriteRawTag(53);
        output.WriteFloat(Multiplier);
      }
      if (HasRateLimitCount) {
        output.WriteRawTag(56);
        output.WriteUInt32(RateLimitCount);
      }
      if (HasRateLimitSeconds) {
        output.WriteRawTag(64);
        output.WriteUInt32(RateLimitSeconds);
      }
      if (HasMaxPacketSize) {
        output.WriteRawTag(72);
        output.WriteUInt32(MaxPacketSize);
      }
      if (HasMaxEncodedSize) {
        output.WriteRawTag(80);
        output.WriteUInt32(MaxEncodedSize);
      }
      if (HasTimeout) {
        output.WriteRawTag(93);
        output.WriteFloat(Timeout);
      }
      if (HasCapBalance) {
        output.WriteRawTag(96);
        output.WriteUInt32(CapBalance);
      }
      if (HasIncomePerSecond) {
        output.WriteRawTag(109);
        output.WriteFloat(IncomePerSecond);
      }
      if (HasServiceHash) {
        output.WriteRawTag(112);
        output.WriteUInt32(ServiceHash);
      }
      if (HasMethodId) {
        output.WriteRawTag(120);
        output.WriteUInt32(MethodId);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (HasServiceName) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceName);
      }
      if (HasMethodName) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(MethodName);
      }
      if (HasFixedCallCost) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(FixedCallCost);
      }
      if (HasFixedPacketSize) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(FixedPacketSize);
      }
      if (HasVariableMultiplier) {
        size += 1 + 4;
      }
      if (HasMultiplier) {
        size += 1 + 4;
      }
      if (HasRateLimitCount) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RateLimitCount);
      }
      if (HasRateLimitSeconds) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RateLimitSeconds);
      }
      if (HasMaxPacketSize) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MaxPacketSize);
      }
      if (HasMaxEncodedSize) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MaxEncodedSize);
      }
      if (HasTimeout) {
        size += 1 + 4;
      }
      if (HasCapBalance) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(CapBalance);
      }
      if (HasIncomePerSecond) {
        size += 1 + 4;
      }
      if (HasServiceHash) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ServiceHash);
      }
      if (HasMethodId) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MethodId);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(RPCMethodConfig other) {
      if (other == null) {
        return;
      }
      if (other.HasServiceName) {
        ServiceName = other.ServiceName;
      }
      if (other.HasMethodName) {
        MethodName = other.MethodName;
      }
      if (other.HasFixedCallCost) {
        FixedCallCost = other.FixedCallCost;
      }
      if (other.HasFixedPacketSize) {
        FixedPacketSize = other.FixedPacketSize;
      }
      if (other.HasVariableMultiplier) {
        VariableMultiplier = other.VariableMultiplier;
      }
      if (other.HasMultiplier) {
        Multiplier = other.Multiplier;
      }
      if (other.HasRateLimitCount) {
        RateLimitCount = other.RateLimitCount;
      }
      if (other.HasRateLimitSeconds) {
        RateLimitSeconds = other.RateLimitSeconds;
      }
      if (other.HasMaxPacketSize) {
        MaxPacketSize = other.MaxPacketSize;
      }
      if (other.HasMaxEncodedSize) {
        MaxEncodedSize = other.MaxEncodedSize;
      }
      if (other.HasTimeout) {
        Timeout = other.Timeout;
      }
      if (other.HasCapBalance) {
        CapBalance = other.CapBalance;
      }
      if (other.HasIncomePerSecond) {
        IncomePerSecond = other.IncomePerSecond;
      }
      if (other.HasServiceHash) {
        ServiceHash = other.ServiceHash;
      }
      if (other.HasMethodId) {
        MethodId = other.MethodId;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            ServiceName = input.ReadString();
            break;
          }
          case 18: {
            MethodName = input.ReadString();
            break;
          }
          case 24: {
            FixedCallCost = input.ReadUInt32();
            break;
          }
          case 32: {
            FixedPacketSize = input.ReadUInt32();
            break;
          }
          case 45: {
            VariableMultiplier = input.ReadFloat();
            break;
          }
          case 53: {
            Multiplier = input.ReadFloat();
            break;
          }
          case 56: {
            RateLimitCount = input.ReadUInt32();
            break;
          }
          case 64: {
            RateLimitSeconds = input.ReadUInt32();
            break;
          }
          case 72: {
            MaxPacketSize = input.ReadUInt32();
            break;
          }
          case 80: {
            MaxEncodedSize = input.ReadUInt32();
            break;
          }
          case 93: {
            Timeout = input.ReadFloat();
            break;
          }
          case 96: {
            CapBalance = input.ReadUInt32();
            break;
          }
          case 109: {
            IncomePerSecond = input.ReadFloat();
            break;
          }
          case 112: {
            ServiceHash = input.ReadUInt32();
            break;
          }
          case 120: {
            MethodId = input.ReadUInt32();
            break;
          }
        }
      }
    }

  }

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

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Bgs.Protocol.Config.RpcConfigReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RPCMeterConfig() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RPCMeterConfig(RPCMeterConfig other) : this() {
      _hasBits0 = other._hasBits0;
      method_ = other.method_.Clone();
      incomePerSecond_ = other.incomePerSecond_;
      initialBalance_ = other.initialBalance_;
      capBalance_ = other.capBalance_;
      startupPeriod_ = other.startupPeriod_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RPCMeterConfig Clone() {
      return new RPCMeterConfig(this);
    }

    /// <summary>Field number for the "method" field.</summary>
    public const int MethodFieldNumber = 1;
    private static readonly pb::FieldCodec<global::Bgs.Protocol.Config.RPCMethodConfig> _repeated_method_codec
        = pb::FieldCodec.ForMessage(10, global::Bgs.Protocol.Config.RPCMethodConfig.Parser);
    private readonly pbc::RepeatedField<global::Bgs.Protocol.Config.RPCMethodConfig> method_ = new pbc::RepeatedField<global::Bgs.Protocol.Config.RPCMethodConfig>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Bgs.Protocol.Config.RPCMethodConfig> Method {
      get { return method_; }
    }

    /// <summary>Field number for the "income_per_second" field.</summary>
    public const int IncomePerSecondFieldNumber = 2;
    private readonly static uint IncomePerSecondDefaultValue = 1;

    private uint incomePerSecond_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint IncomePerSecond {
      get { if ((_hasBits0 & 1) != 0) { return incomePerSecond_; } else { return IncomePerSecondDefaultValue; } }
      set {
        _hasBits0 |= 1;
        incomePerSecond_ = value;
      }
    }
    /// <summary>Gets whether the "income_per_second" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasIncomePerSecond {
      get { return (_hasBits0 & 1) != 0; }
    }
    /// <summary>Clears the value of the "income_per_second" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearIncomePerSecond() {
      _hasBits0 &= ~1;
    }

    /// <summary>Field number for the "initial_balance" field.</summary>
    public const int InitialBalanceFieldNumber = 3;
    private readonly static uint InitialBalanceDefaultValue = 0;

    private uint initialBalance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint InitialBalance {
      get { if ((_hasBits0 & 2) != 0) { return initialBalance_; } else { return InitialBalanceDefaultValue; } }
      set {
        _hasBits0 |= 2;
        initialBalance_ = value;
      }
    }
    /// <summary>Gets whether the "initial_balance" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasInitialBalance {
      get { return (_hasBits0 & 2) != 0; }
    }
    /// <summary>Clears the value of the "initial_balance" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearInitialBalance() {
      _hasBits0 &= ~2;
    }

    /// <summary>Field number for the "cap_balance" field.</summary>
    public const int CapBalanceFieldNumber = 4;
    private readonly static uint CapBalanceDefaultValue = 0;

    private uint capBalance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public uint CapBalance {
      get { if ((_hasBits0 & 4) != 0) { return capBalance_; } else { return CapBalanceDefaultValue; } }
      set {
        _hasBits0 |= 4;
        capBalance_ = value;
      }
    }
    /// <summary>Gets whether the "cap_balance" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasCapBalance {
      get { return (_hasBits0 & 4) != 0; }
    }
    /// <summary>Clears the value of the "cap_balance" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearCapBalance() {
      _hasBits0 &= ~4;
    }

    /// <summary>Field number for the "startup_period" field.</summary>
    public const int StartupPeriodFieldNumber = 5;
    private readonly static float StartupPeriodDefaultValue = 0F;

    private float startupPeriod_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public float StartupPeriod {
      get { if ((_hasBits0 & 8) != 0) { return startupPeriod_; } else { return StartupPeriodDefaultValue; } }
      set {
        _hasBits0 |= 8;
        startupPeriod_ = value;
      }
    }
    /// <summary>Gets whether the "startup_period" field is set</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool HasStartupPeriod {
      get { return (_hasBits0 & 8) != 0; }
    }
    /// <summary>Clears the value of the "startup_period" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearStartupPeriod() {
      _hasBits0 &= ~8;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as RPCMeterConfig);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(RPCMeterConfig other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!method_.Equals(other.method_)) return false;
      if (IncomePerSecond != other.IncomePerSecond) return false;
      if (InitialBalance != other.InitialBalance) return false;
      if (CapBalance != other.CapBalance) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StartupPeriod, other.StartupPeriod)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= method_.GetHashCode();
      if (HasIncomePerSecond) hash ^= IncomePerSecond.GetHashCode();
      if (HasInitialBalance) hash ^= InitialBalance.GetHashCode();
      if (HasCapBalance) hash ^= CapBalance.GetHashCode();
      if (HasStartupPeriod) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StartupPeriod);
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      method_.WriteTo(output, _repeated_method_codec);
      if (HasIncomePerSecond) {
        output.WriteRawTag(16);
        output.WriteUInt32(IncomePerSecond);
      }
      if (HasInitialBalance) {
        output.WriteRawTag(24);
        output.WriteUInt32(InitialBalance);
      }
      if (HasCapBalance) {
        output.WriteRawTag(32);
        output.WriteUInt32(CapBalance);
      }
      if (HasStartupPeriod) {
        output.WriteRawTag(45);
        output.WriteFloat(StartupPeriod);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += method_.CalculateSize(_repeated_method_codec);
      if (HasIncomePerSecond) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(IncomePerSecond);
      }
      if (HasInitialBalance) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InitialBalance);
      }
      if (HasCapBalance) {
        size += 1 + pb::CodedOutputStream.ComputeUInt32Size(CapBalance);
      }
      if (HasStartupPeriod) {
        size += 1 + 4;
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(RPCMeterConfig other) {
      if (other == null) {
        return;
      }
      method_.Add(other.method_);
      if (other.HasIncomePerSecond) {
        IncomePerSecond = other.IncomePerSecond;
      }
      if (other.HasInitialBalance) {
        InitialBalance = other.InitialBalance;
      }
      if (other.HasCapBalance) {
        CapBalance = other.CapBalance;
      }
      if (other.HasStartupPeriod) {
        StartupPeriod = other.StartupPeriod;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            method_.AddEntriesFrom(input, _repeated_method_codec);
            break;
          }
          case 16: {
            IncomePerSecond = input.ReadUInt32();
            break;
          }
          case 24: {
            InitialBalance = input.ReadUInt32();
            break;
          }
          case 32: {
            CapBalance = input.ReadUInt32();
            break;
          }
          case 45: {
            StartupPeriod = input.ReadFloat();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code