path: root/csharp/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs

// Generated by ProtoGen, Version=2.4.1.555, Culture=neutral, PublicKeyToken=55f7125234beb589.  DO NOT EDIT!
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.DescriptorProtos {
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public static partial class CSharpOptions {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
      registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFileOptions);
      registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFieldOptions);
      registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpServiceOptions);
      registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpMethodOptions);
    }
    #endregion
    #region Extensions
    public const int CSharpFileOptionsFieldNumber = 1000;
    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions> CSharpFileOptions;
    public const int CSharpFieldOptionsFieldNumber = 1000;
    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions> CSharpFieldOptions;
    public const int CsharpServiceOptionsFieldNumber = 1000;
    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions> CsharpServiceOptions;
    public const int CsharpMethodOptionsFieldNumber = 1000;
    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions> CsharpMethodOptions;
    #endregion
    
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpFileOptions__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder> internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpFieldOptions__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder> internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpServiceOptions__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Builder> internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpMethodOptions__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Builder> internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static CSharpOptions() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds", 
            "ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8i", 
            "pwQKEUNTaGFycEZpbGVPcHRpb25zEhEKCW5hbWVzcGFjZRgBIAEoCRIaChJ1", 
            "bWJyZWxsYV9jbGFzc25hbWUYAiABKAkSHAoOcHVibGljX2NsYXNzZXMYAyAB", 
            "KAg6BHRydWUSFgoObXVsdGlwbGVfZmlsZXMYBCABKAgSFAoMbmVzdF9jbGFz", 
            "c2VzGAUgASgIEhYKDmNvZGVfY29udHJhY3RzGAYgASgIEiQKHGV4cGFuZF9u", 
            "YW1lc3BhY2VfZGlyZWN0b3JpZXMYByABKAgSHAoOY2xzX2NvbXBsaWFuY2UY", 
            "CCABKAg6BHRydWUSHwoQYWRkX3NlcmlhbGl6YWJsZRgJIAEoCDoFZmFsc2US", 
            "IwoVZ2VuZXJhdGVfcHJpdmF0ZV9jdG9yGAogASgIOgR0cnVlEhwKDmZpbGVf", 
            "ZXh0ZW5zaW9uGN0BIAEoCToDLmNzEhsKEnVtYnJlbGxhX25hbWVzcGFjZRje", 
            "ASABKAkSHAoQb3V0cHV0X2RpcmVjdG9yeRjfASABKAk6AS4SJgoWaWdub3Jl", 
            "X2dvb2dsZV9wcm90b2J1ZhjgASABKAg6BWZhbHNlEkkKFnNlcnZpY2VfZ2Vu", 
            "ZXJhdG9yX3R5cGUY4QEgASgOMiIuZ29vZ2xlLnByb3RvYnVmLkNTaGFycFNl", 
            "cnZpY2VUeXBlOgROT05FEikKGWdlbmVyYXRlZF9jb2RlX2F0dHJpYnV0ZXMY", 
            "4gEgASgIOgVmYWxzZSIrChJDU2hhcnBGaWVsZE9wdGlvbnMSFQoNcHJvcGVy", 
            "dHlfbmFtZRgBIAEoCSIsChRDU2hhcnBTZXJ2aWNlT3B0aW9ucxIUCgxpbnRl", 
            "cmZhY2VfaWQYASABKAkiKgoTQ1NoYXJwTWV0aG9kT3B0aW9ucxITCgtkaXNw", 
            "YXRjaF9pZBgBIAEoBSpLChFDU2hhcnBTZXJ2aWNlVHlwZRIICgROT05FEAAS", 
            "CwoHR0VORVJJQxABEg0KCUlOVEVSRkFDRRACEhAKDElSUENESVNQQVRDSBAD", 
            "Ol4KE2NzaGFycF9maWxlX29wdGlvbnMSHC5nb29nbGUucHJvdG9idWYuRmls", 
            "ZU9wdGlvbnMY6AcgASgLMiIuZ29vZ2xlLnByb3RvYnVmLkNTaGFycEZpbGVP", 
            "cHRpb25zOmEKFGNzaGFycF9maWVsZF9vcHRpb25zEh0uZ29vZ2xlLnByb3Rv", 
            "YnVmLkZpZWxkT3B0aW9ucxjoByABKAsyIy5nb29nbGUucHJvdG9idWYuQ1No", 
            "YXJwRmllbGRPcHRpb25zOmcKFmNzaGFycF9zZXJ2aWNlX29wdGlvbnMSHy5n", 
            "b29nbGUucHJvdG9idWYuU2VydmljZU9wdGlvbnMY6AcgASgLMiUuZ29vZ2xl", 
            "LnByb3RvYnVmLkNTaGFycFNlcnZpY2VPcHRpb25zOmQKFWNzaGFycF9tZXRo", 
            "b2Rfb3B0aW9ucxIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGOgH", 
          "IAEoCzIkLmdvb2dsZS5wcm90b2J1Zi5DU2hhcnBNZXRob2RPcHRpb25z"));
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_google_protobuf_CSharpFileOptions__Descriptor = Descriptor.MessageTypes[0];
        internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder>(internal__static_google_protobuf_CSharpFileOptions__Descriptor,
                new string[] { "Namespace", "UmbrellaClassname", "PublicClasses", "MultipleFiles", "NestClasses", "CodeContracts", "ExpandNamespaceDirectories", "ClsCompliance", "AddSerializable", "GeneratePrivateCtor", "FileExtension", "UmbrellaNamespace", "OutputDirectory", "IgnoreGoogleProtobuf", "ServiceGeneratorType", "GeneratedCodeAttributes", });
        internal__static_google_protobuf_CSharpFieldOptions__Descriptor = Descriptor.MessageTypes[1];
        internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder>(internal__static_google_protobuf_CSharpFieldOptions__Descriptor,
                new string[] { "PropertyName", });
        internal__static_google_protobuf_CSharpServiceOptions__Descriptor = Descriptor.MessageTypes[2];
        internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Builder>(internal__static_google_protobuf_CSharpServiceOptions__Descriptor,
                new string[] { "InterfaceId", });
        internal__static_google_protobuf_CSharpMethodOptions__Descriptor = Descriptor.MessageTypes[3];
        internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Builder>(internal__static_google_protobuf_CSharpMethodOptions__Descriptor,
                new string[] { "DispatchId", });
        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFileOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[0]);
        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFieldOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[1]);
        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpServiceOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[2]);
        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpMethodOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[3]);
        return null;
      };
      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
          new pbd::FileDescriptor[] {
          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, 
          }, assigner);
    }
    #endregion
    
  }
  #region Enums
  public enum CSharpServiceType {
    NONE = 0,
    GENERIC = 1,
    INTERFACE = 2,
    IRPCDISPATCH = 3,
  }
  
  #endregion
  
  #region Messages
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class CSharpFileOptions : pb::GeneratedMessage<CSharpFileOptions, CSharpFileOptions.Builder> {
    private CSharpFileOptions() { }
    private static readonly CSharpFileOptions defaultInstance = new CSharpFileOptions().MakeReadOnly();
    private static readonly string[] _cSharpFileOptionsFieldNames = new string[] { "add_serializable", "cls_compliance", "code_contracts", "expand_namespace_directories", "file_extension", "generate_private_ctor", "generated_code_attributes", "ignore_google_protobuf", "multiple_files", "namespace", "nest_classes", "output_directory", "public_classes", "service_generator_type", "umbrella_classname", "umbrella_namespace" };
    private static readonly uint[] _cSharpFileOptionsFieldTags = new uint[] { 72, 64, 48, 56, 1770, 80, 1808, 1792, 32, 10, 40, 1786, 24, 1800, 18, 1778 };
    public static CSharpFileOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CSharpFileOptions DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override CSharpFileOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CSharpFileOptions, CSharpFileOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable; }
    }
    
    public const int NamespaceFieldNumber = 1;
    private bool hasNamespace;
    private string namespace_ = "";
    public bool HasNamespace {
      get { return hasNamespace; }
    }
    public string Namespace {
      get { return namespace_; }
    }
    
    public const int UmbrellaClassnameFieldNumber = 2;
    private bool hasUmbrellaClassname;
    private string umbrellaClassname_ = "";
    public bool HasUmbrellaClassname {
      get { return hasUmbrellaClassname; }
    }
    public string UmbrellaClassname {
      get { return umbrellaClassname_; }
    }
    
    public const int PublicClassesFieldNumber = 3;
    private bool hasPublicClasses;
    private bool publicClasses_ = true;
    public bool HasPublicClasses {
      get { return hasPublicClasses; }
    }
    public bool PublicClasses {
      get { return publicClasses_; }
    }
    
    public const int MultipleFilesFieldNumber = 4;
    private bool hasMultipleFiles;
    private bool multipleFiles_;
    public bool HasMultipleFiles {
      get { return hasMultipleFiles; }
    }
    public bool MultipleFiles {
      get { return multipleFiles_; }
    }
    
    public const int NestClassesFieldNumber = 5;
    private bool hasNestClasses;
    private bool nestClasses_;
    public bool HasNestClasses {
      get { return hasNestClasses; }
    }
    public bool NestClasses {
      get { return nestClasses_; }
    }
    
    public const int CodeContractsFieldNumber = 6;
    private bool hasCodeContracts;
    private bool codeContracts_;
    public bool HasCodeContracts {
      get { return hasCodeContracts; }
    }
    public bool CodeContracts {
      get { return codeContracts_; }
    }
    
    public const int ExpandNamespaceDirectoriesFieldNumber = 7;
    private bool hasExpandNamespaceDirectories;
    private bool expandNamespaceDirectories_;
    public bool HasExpandNamespaceDirectories {
      get { return hasExpandNamespaceDirectories; }
    }
    public bool ExpandNamespaceDirectories {
      get { return expandNamespaceDirectories_; }
    }
    
    public const int ClsComplianceFieldNumber = 8;
    private bool hasClsCompliance;
    private bool clsCompliance_ = true;
    public bool HasClsCompliance {
      get { return hasClsCompliance; }
    }
    public bool ClsCompliance {
      get { return clsCompliance_; }
    }
    
    public const int AddSerializableFieldNumber = 9;
    private bool hasAddSerializable;
    private bool addSerializable_;
    public bool HasAddSerializable {
      get { return hasAddSerializable; }
    }
    public bool AddSerializable {
      get { return addSerializable_; }
    }
    
    public const int GeneratePrivateCtorFieldNumber = 10;
    private bool hasGeneratePrivateCtor;
    private bool generatePrivateCtor_ = true;
    public bool HasGeneratePrivateCtor {
      get { return hasGeneratePrivateCtor; }
    }
    public bool GeneratePrivateCtor {
      get { return generatePrivateCtor_; }
    }
    
    public const int FileExtensionFieldNumber = 221;
    private bool hasFileExtension;
    private string fileExtension_ = ".cs";
    public bool HasFileExtension {
      get { return hasFileExtension; }
    }
    public string FileExtension {
      get { return fileExtension_; }
    }
    
    public const int UmbrellaNamespaceFieldNumber = 222;
    private bool hasUmbrellaNamespace;
    private string umbrellaNamespace_ = "";
    public bool HasUmbrellaNamespace {
      get { return hasUmbrellaNamespace; }
    }
    public string UmbrellaNamespace {
      get { return umbrellaNamespace_; }
    }
    
    public const int OutputDirectoryFieldNumber = 223;
    private bool hasOutputDirectory;
    private string outputDirectory_ = ".";
    public bool HasOutputDirectory {
      get { return hasOutputDirectory; }
    }
    public string OutputDirectory {
      get { return outputDirectory_; }
    }
    
    public const int IgnoreGoogleProtobufFieldNumber = 224;
    private bool hasIgnoreGoogleProtobuf;
    private bool ignoreGoogleProtobuf_;
    public bool HasIgnoreGoogleProtobuf {
      get { return hasIgnoreGoogleProtobuf; }
    }
    public bool IgnoreGoogleProtobuf {
      get { return ignoreGoogleProtobuf_; }
    }
    
    public const int ServiceGeneratorTypeFieldNumber = 225;
    private bool hasServiceGeneratorType;
    private global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType serviceGeneratorType_ = global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType.NONE;
    public bool HasServiceGeneratorType {
      get { return hasServiceGeneratorType; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {
      get { return serviceGeneratorType_; }
    }
    
    public const int GeneratedCodeAttributesFieldNumber = 226;
    private bool hasGeneratedCodeAttributes;
    private bool generatedCodeAttributes_;
    public bool HasGeneratedCodeAttributes {
      get { return hasGeneratedCodeAttributes; }
    }
    public bool GeneratedCodeAttributes {
      get { return generatedCodeAttributes_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      CalcSerializedSize();
      string[] field_names = _cSharpFileOptionsFieldNames;
      if (hasNamespace) {
        output.WriteString(1, field_names[9], Namespace);
      }
      if (hasUmbrellaClassname) {
        output.WriteString(2, field_names[14], UmbrellaClassname);
      }
      if (hasPublicClasses) {
        output.WriteBool(3, field_names[12], PublicClasses);
      }
      if (hasMultipleFiles) {
        output.WriteBool(4, field_names[8], MultipleFiles);
      }
      if (hasNestClasses) {
        output.WriteBool(5, field_names[10], NestClasses);
      }
      if (hasCodeContracts) {
        output.WriteBool(6, field_names[2], CodeContracts);
      }
      if (hasExpandNamespaceDirectories) {
        output.WriteBool(7, field_names[3], ExpandNamespaceDirectories);
      }
      if (hasClsCompliance) {
        output.WriteBool(8, field_names[1], ClsCompliance);
      }
      if (hasAddSerializable) {
        output.WriteBool(9, field_names[0], AddSerializable);
      }
      if (hasGeneratePrivateCtor) {
        output.WriteBool(10, field_names[5], GeneratePrivateCtor);
      }
      if (hasFileExtension) {
        output.WriteString(221, field_names[4], FileExtension);
      }
      if (hasUmbrellaNamespace) {
        output.WriteString(222, field_names[15], UmbrellaNamespace);
      }
      if (hasOutputDirectory) {
        output.WriteString(223, field_names[11], OutputDirectory);
      }
      if (hasIgnoreGoogleProtobuf) {
        output.WriteBool(224, field_names[7], IgnoreGoogleProtobuf);
      }
      if (hasServiceGeneratorType) {
        output.WriteEnum(225, field_names[13], (int) ServiceGeneratorType, ServiceGeneratorType);
      }
      if (hasGeneratedCodeAttributes) {
        output.WriteBool(226, field_names[6], GeneratedCodeAttributes);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        return CalcSerializedSize();
      }
    }
    
    private int CalcSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasNamespace) {
        size += pb::CodedOutputStream.ComputeStringSize(1, Namespace);
      }
      if (hasUmbrellaClassname) {
        size += pb::CodedOutputStream.ComputeStringSize(2, UmbrellaClassname);
      }
      if (hasPublicClasses) {
        size += pb::CodedOutputStream.ComputeBoolSize(3, PublicClasses);
      }
      if (hasMultipleFiles) {
        size += pb::CodedOutputStream.ComputeBoolSize(4, MultipleFiles);
      }
      if (hasNestClasses) {
        size += pb::CodedOutputStream.ComputeBoolSize(5, NestClasses);
      }
      if (hasCodeContracts) {
        size += pb::CodedOutputStream.ComputeBoolSize(6, CodeContracts);
      }
      if (hasExpandNamespaceDirectories) {
        size += pb::CodedOutputStream.ComputeBoolSize(7, ExpandNamespaceDirectories);
      }
      if (hasClsCompliance) {
        size += pb::CodedOutputStream.ComputeBoolSize(8, ClsCompliance);
      }
      if (hasAddSerializable) {
        size += pb::CodedOutputStream.ComputeBoolSize(9, AddSerializable);
      }
      if (hasGeneratePrivateCtor) {
        size += pb::CodedOutputStream.ComputeBoolSize(10, GeneratePrivateCtor);
      }
      if (hasFileExtension) {
        size += pb::CodedOutputStream.ComputeStringSize(221, FileExtension);
      }
      if (hasUmbrellaNamespace) {
        size += pb::CodedOutputStream.ComputeStringSize(222, UmbrellaNamespace);
      }
      if (hasOutputDirectory) {
        size += pb::CodedOutputStream.ComputeStringSize(223, OutputDirectory);
      }
      if (hasIgnoreGoogleProtobuf) {
        size += pb::CodedOutputStream.ComputeBoolSize(224, IgnoreGoogleProtobuf);
      }
      if (hasServiceGeneratorType) {
        size += pb::CodedOutputStream.ComputeEnumSize(225, (int) ServiceGeneratorType);
      }
      if (hasGeneratedCodeAttributes) {
        size += pb::CodedOutputStream.ComputeBoolSize(226, GeneratedCodeAttributes);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
    public static CSharpFileOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CSharpFileOptions ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CSharpFileOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private CSharpFileOptions MakeReadOnly() {
      return this;
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CSharpFileOptions prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<CSharpFileOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(CSharpFileOptions cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private CSharpFileOptions result;
      
      private CSharpFileOptions PrepareBuilder() {
        if (resultIsReadOnly) {
          CSharpFileOptions original = result;
          result = new CSharpFileOptions();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override CSharpFileOptions MessageBeingBuilt {
        get { return PrepareBuilder(); }
      }
      
      public override Builder Clear() {
        result = DefaultInstance;
        resultIsReadOnly = true;
        return this;
      }
      
      public override Builder Clone() {
        if (resultIsReadOnly) {
          return new Builder(result);
        } else {
          return new Builder().MergeFrom(result);
        }
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Descriptor; }
      }
      
      public override CSharpFileOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.DefaultInstance; }
      }
      
      public override CSharpFileOptions BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CSharpFileOptions) {
          return MergeFrom((CSharpFileOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CSharpFileOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasNamespace) {
          Namespace = other.Namespace;
        }
        if (other.HasUmbrellaClassname) {
          UmbrellaClassname = other.UmbrellaClassname;
        }
        if (other.HasPublicClasses) {
          PublicClasses = other.PublicClasses;
        }
        if (other.HasMultipleFiles) {
          MultipleFiles = other.MultipleFiles;
        }
        if (other.HasNestClasses) {
          NestClasses = other.NestClasses;
        }
        if (other.HasCodeContracts) {
          CodeContracts = other.CodeContracts;
        }
        if (other.HasExpandNamespaceDirectories) {
          ExpandNamespaceDirectories = other.ExpandNamespaceDirectories;
        }
        if (other.HasClsCompliance) {
          ClsCompliance = other.ClsCompliance;
        }
        if (other.HasAddSerializable) {
          AddSerializable = other.AddSerializable;
        }
        if (other.HasGeneratePrivateCtor) {
          GeneratePrivateCtor = other.GeneratePrivateCtor;
        }
        if (other.HasFileExtension) {
          FileExtension = other.FileExtension;
        }
        if (other.HasUmbrellaNamespace) {
          UmbrellaNamespace = other.UmbrellaNamespace;
        }
        if (other.HasOutputDirectory) {
          OutputDirectory = other.OutputDirectory;
        }
        if (other.HasIgnoreGoogleProtobuf) {
          IgnoreGoogleProtobuf = other.IgnoreGoogleProtobuf;
        }
        if (other.HasServiceGeneratorType) {
          ServiceGeneratorType = other.ServiceGeneratorType;
        }
        if (other.HasGeneratedCodeAttributes) {
          GeneratedCodeAttributes = other.GeneratedCodeAttributes;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        PrepareBuilder();
        pb::UnknownFieldSet.Builder unknownFields = null;
        uint tag;
        string field_name;
        while (input.ReadTag(out tag, out field_name)) {
          if(tag == 0 && field_name != null) {
            int field_ordinal = global::System.Array.BinarySearch(_cSharpFileOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _cSharpFileOptionsFieldTags[field_ordinal];
            else {
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              continue;
            }
          }
          switch (tag) {
            case 0: {
              throw pb::InvalidProtocolBufferException.InvalidTag();
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              break;
            }
            case 10: {
              result.hasNamespace = input.ReadString(ref result.namespace_);
              break;
            }
            case 18: {
              result.hasUmbrellaClassname = input.ReadString(ref result.umbrellaClassname_);
              break;
            }
            case 24: {
              result.hasPublicClasses = input.ReadBool(ref result.publicClasses_);
              break;
            }
            case 32: {
              result.hasMultipleFiles = input.ReadBool(ref result.multipleFiles_);
              break;
            }
            case 40: {
              result.hasNestClasses = input.ReadBool(ref result.nestClasses_);
              break;
            }
            case 48: {
              result.hasCodeContracts = input.ReadBool(ref result.codeContracts_);
              break;
            }
            case 56: {
              result.hasExpandNamespaceDirectories = input.ReadBool(ref result.expandNamespaceDirectories_);
              break;
            }
            case 64: {
              result.hasClsCompliance = input.ReadBool(ref result.clsCompliance_);
              break;
            }
            case 72: {
              result.hasAddSerializable = input.ReadBool(ref result.addSerializable_);
              break;
            }
            case 80: {
              result.hasGeneratePrivateCtor = input.ReadBool(ref result.generatePrivateCtor_);
              break;
            }
            case 1770: {
              result.hasFileExtension = input.ReadString(ref result.fileExtension_);
              break;
            }
            case 1778: {
              result.hasUmbrellaNamespace = input.ReadString(ref result.umbrellaNamespace_);
              break;
            }
            case 1786: {
              result.hasOutputDirectory = input.ReadString(ref result.outputDirectory_);
              break;
            }
            case 1792: {
              result.hasIgnoreGoogleProtobuf = input.ReadBool(ref result.ignoreGoogleProtobuf_);
              break;
            }
            case 1800: {
              object unknown;
              if(input.ReadEnum(ref result.serviceGeneratorType_, out unknown)) {
                result.hasServiceGeneratorType = true;
              } else if(unknown is int) {
                if (unknownFields == null) {
                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                }
                unknownFields.MergeVarintField(225, (ulong)(int)unknown);
              }
              break;
            }
            case 1808: {
              result.hasGeneratedCodeAttributes = input.ReadBool(ref result.generatedCodeAttributes_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasNamespace {
        get { return result.hasNamespace; }
      }
      public string Namespace {
        get { return result.Namespace; }
        set { SetNamespace(value); }
      }
      public Builder SetNamespace(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasNamespace = true;
        result.namespace_ = value;
        return this;
      }
      public Builder ClearNamespace() {
        PrepareBuilder();
        result.hasNamespace = false;
        result.namespace_ = "";
        return this;
      }
      
      public bool HasUmbrellaClassname {
        get { return result.hasUmbrellaClassname; }
      }
      public string UmbrellaClassname {
        get { return result.UmbrellaClassname; }
        set { SetUmbrellaClassname(value); }
      }
      public Builder SetUmbrellaClassname(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasUmbrellaClassname = true;
        result.umbrellaClassname_ = value;
        return this;
      }
      public Builder ClearUmbrellaClassname() {
        PrepareBuilder();
        result.hasUmbrellaClassname = false;
        result.umbrellaClassname_ = "";
        return this;
      }
      
      public bool HasPublicClasses {
        get { return result.hasPublicClasses; }
      }
      public bool PublicClasses {
        get { return result.PublicClasses; }
        set { SetPublicClasses(value); }
      }
      public Builder SetPublicClasses(bool value) {
        PrepareBuilder();
        result.hasPublicClasses = true;
        result.publicClasses_ = value;
        return this;
      }
      public Builder ClearPublicClasses() {
        PrepareBuilder();
        result.hasPublicClasses = false;
        result.publicClasses_ = true;
        return this;
      }
      
      public bool HasMultipleFiles {
        get { return result.hasMultipleFiles; }
      }
      public bool MultipleFiles {
        get { return result.MultipleFiles; }
        set { SetMultipleFiles(value); }
      }
      public Builder SetMultipleFiles(bool value) {
        PrepareBuilder();
        result.hasMultipleFiles = true;
        result.multipleFiles_ = value;
        return this;
      }
      public Builder ClearMultipleFiles() {
        PrepareBuilder();
        result.hasMultipleFiles = false;
        result.multipleFiles_ = false;
        return this;
      }
      
      public bool HasNestClasses {
        get { return result.hasNestClasses; }
      }
      public bool NestClasses {
        get { return result.NestClasses; }
        set { SetNestClasses(value); }
      }
      public Builder SetNestClasses(bool value) {
        PrepareBuilder();
        result.hasNestClasses = true;
        result.nestClasses_ = value;
        return this;
      }
      public Builder ClearNestClasses() {
        PrepareBuilder();
        result.hasNestClasses = false;
        result.nestClasses_ = false;
        return this;
      }
      
      public bool HasCodeContracts {
        get { return result.hasCodeContracts; }
      }
      public bool CodeContracts {
        get { return result.CodeContracts; }
        set { SetCodeContracts(value); }
      }
      public Builder SetCodeContracts(bool value) {
        PrepareBuilder();
        result.hasCodeContracts = true;
        result.codeContracts_ = value;
        return this;
      }
      public Builder ClearCodeContracts() {
        PrepareBuilder();
        result.hasCodeContracts = false;
        result.codeContracts_ = false;
        return this;
      }
      
      public bool HasExpandNamespaceDirectories {
        get { return result.hasExpandNamespaceDirectories; }
      }
      public bool ExpandNamespaceDirectories {
        get { return result.ExpandNamespaceDirectories; }
        set { SetExpandNamespaceDirectories(value); }
      }
      public Builder SetExpandNamespaceDirectories(bool value) {
        PrepareBuilder();
        result.hasExpandNamespaceDirectories = true;
        result.expandNamespaceDirectories_ = value;
        return this;
      }
      public Builder ClearExpandNamespaceDirectories() {
        PrepareBuilder();
        result.hasExpandNamespaceDirectories = false;
        result.expandNamespaceDirectories_ = false;
        return this;
      }
      
      public bool HasClsCompliance {
        get { return result.hasClsCompliance; }
      }
      public bool ClsCompliance {
        get { return result.ClsCompliance; }
        set { SetClsCompliance(value); }
      }
      public Builder SetClsCompliance(bool value) {
        PrepareBuilder();
        result.hasClsCompliance = true;
        result.clsCompliance_ = value;
        return this;
      }
      public Builder ClearClsCompliance() {
        PrepareBuilder();
        result.hasClsCompliance = false;
        result.clsCompliance_ = true;
        return this;
      }
      
      public bool HasAddSerializable {
        get { return result.hasAddSerializable; }
      }
      public bool AddSerializable {
        get { return result.AddSerializable; }
        set { SetAddSerializable(value); }
      }
      public Builder SetAddSerializable(bool value) {
        PrepareBuilder();
        result.hasAddSerializable = true;
        result.addSerializable_ = value;
        return this;
      }
      public Builder ClearAddSerializable() {
        PrepareBuilder();
        result.hasAddSerializable = false;
        result.addSerializable_ = false;
        return this;
      }
      
      public bool HasGeneratePrivateCtor {
        get { return result.hasGeneratePrivateCtor; }
      }
      public bool GeneratePrivateCtor {
        get { return result.GeneratePrivateCtor; }
        set { SetGeneratePrivateCtor(value); }
      }
      public Builder SetGeneratePrivateCtor(bool value) {
        PrepareBuilder();
        result.hasGeneratePrivateCtor = true;
        result.generatePrivateCtor_ = value;
        return this;
      }
      public Builder ClearGeneratePrivateCtor() {
        PrepareBuilder();
        result.hasGeneratePrivateCtor = false;
        result.generatePrivateCtor_ = true;
        return this;
      }
      
      public bool HasFileExtension {
        get { return result.hasFileExtension; }
      }
      public string FileExtension {
        get { return result.FileExtension; }
        set { SetFileExtension(value); }
      }
      public Builder SetFileExtension(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasFileExtension = true;
        result.fileExtension_ = value;
        return this;
      }
      public Builder ClearFileExtension() {
        PrepareBuilder();
        result.hasFileExtension = false;
        result.fileExtension_ = ".cs";
        return this;
      }
      
      public bool HasUmbrellaNamespace {
        get { return result.hasUmbrellaNamespace; }
      }
      public string UmbrellaNamespace {
        get { return result.UmbrellaNamespace; }
        set { SetUmbrellaNamespace(value); }
      }
      public Builder SetUmbrellaNamespace(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasUmbrellaNamespace = true;
        result.umbrellaNamespace_ = value;
        return this;
      }
      public Builder ClearUmbrellaNamespace() {
        PrepareBuilder();
        result.hasUmbrellaNamespace = false;
        result.umbrellaNamespace_ = "";
        return this;
      }
      
      public bool HasOutputDirectory {
        get { return result.hasOutputDirectory; }
      }
      public string OutputDirectory {
        get { return result.OutputDirectory; }
        set { SetOutputDirectory(value); }
      }
      public Builder SetOutputDirectory(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasOutputDirectory = true;
        result.outputDirectory_ = value;
        return this;
      }
      public Builder ClearOutputDirectory() {
        PrepareBuilder();
        result.hasOutputDirectory = false;
        result.outputDirectory_ = ".";
        return this;
      }
      
      public bool HasIgnoreGoogleProtobuf {
        get { return result.hasIgnoreGoogleProtobuf; }
      }
      public bool IgnoreGoogleProtobuf {
        get { return result.IgnoreGoogleProtobuf; }
        set { SetIgnoreGoogleProtobuf(value); }
      }
      public Builder SetIgnoreGoogleProtobuf(bool value) {
        PrepareBuilder();
        result.hasIgnoreGoogleProtobuf = true;
        result.ignoreGoogleProtobuf_ = value;
        return this;
      }
      public Builder ClearIgnoreGoogleProtobuf() {
        PrepareBuilder();
        result.hasIgnoreGoogleProtobuf = false;
        result.ignoreGoogleProtobuf_ = false;
        return this;
      }
      
      public bool HasServiceGeneratorType {
       get { return result.hasServiceGeneratorType; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {
        get { return result.ServiceGeneratorType; }
        set { SetServiceGeneratorType(value); }
      }
      public Builder SetServiceGeneratorType(global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType value) {
        PrepareBuilder();
        result.hasServiceGeneratorType = true;
        result.serviceGeneratorType_ = value;
        return this;
      }
      public Builder ClearServiceGeneratorType() {
        PrepareBuilder();
        result.hasServiceGeneratorType = false;
        result.serviceGeneratorType_ = global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType.NONE;
        return this;
      }
      
      public bool HasGeneratedCodeAttributes {
        get { return result.hasGeneratedCodeAttributes; }
      }
      public bool GeneratedCodeAttributes {
        get { return result.GeneratedCodeAttributes; }
        set { SetGeneratedCodeAttributes(value); }
      }
      public Builder SetGeneratedCodeAttributes(bool value) {
        PrepareBuilder();
        result.hasGeneratedCodeAttributes = true;
        result.generatedCodeAttributes_ = value;
        return this;
      }
      public Builder ClearGeneratedCodeAttributes() {
        PrepareBuilder();
        result.hasGeneratedCodeAttributes = false;
        result.generatedCodeAttributes_ = false;
        return this;
      }
    }
    static CSharpFileOptions() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
    }
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class CSharpFieldOptions : pb::GeneratedMessage<CSharpFieldOptions, CSharpFieldOptions.Builder> {
    private CSharpFieldOptions() { }
    private static readonly CSharpFieldOptions defaultInstance = new CSharpFieldOptions().MakeReadOnly();
    private static readonly string[] _cSharpFieldOptionsFieldNames = new string[] { "property_name" };
    private static readonly uint[] _cSharpFieldOptionsFieldTags = new uint[] { 10 };
    public static CSharpFieldOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CSharpFieldOptions DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override CSharpFieldOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CSharpFieldOptions, CSharpFieldOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable; }
    }
    
    public const int PropertyNameFieldNumber = 1;
    private bool hasPropertyName;
    private string propertyName_ = "";
    public bool HasPropertyName {
      get { return hasPropertyName; }
    }
    public string PropertyName {
      get { return propertyName_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      CalcSerializedSize();
      string[] field_names = _cSharpFieldOptionsFieldNames;
      if (hasPropertyName) {
        output.WriteString(1, field_names[0], PropertyName);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        return CalcSerializedSize();
      }
    }
    
    private int CalcSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasPropertyName) {
        size += pb::CodedOutputStream.ComputeStringSize(1, PropertyName);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
    public static CSharpFieldOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CSharpFieldOptions ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CSharpFieldOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private CSharpFieldOptions MakeReadOnly() {
      return this;
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CSharpFieldOptions prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<CSharpFieldOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(CSharpFieldOptions cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private CSharpFieldOptions result;
      
      private CSharpFieldOptions PrepareBuilder() {
        if (resultIsReadOnly) {
          CSharpFieldOptions original = result;
          result = new CSharpFieldOptions();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override CSharpFieldOptions MessageBeingBuilt {
        get { return PrepareBuilder(); }
      }
      
      public override Builder Clear() {
        result = DefaultInstance;
        resultIsReadOnly = true;
        return this;
      }
      
      public override Builder Clone() {
        if (resultIsReadOnly) {
          return new Builder(result);
        } else {
          return new Builder().MergeFrom(result);
        }
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Descriptor; }
      }
      
      public override CSharpFieldOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.DefaultInstance; }
      }
      
      public override CSharpFieldOptions BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CSharpFieldOptions) {
          return MergeFrom((CSharpFieldOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CSharpFieldOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasPropertyName) {
          PropertyName = other.PropertyName;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        PrepareBuilder();
        pb::UnknownFieldSet.Builder unknownFields = null;
        uint tag;
        string field_name;
        while (input.ReadTag(out tag, out field_name)) {
          if(tag == 0 && field_name != null) {
            int field_ordinal = global::System.Array.BinarySearch(_cSharpFieldOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _cSharpFieldOptionsFieldTags[field_ordinal];
            else {
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              continue;
            }
          }
          switch (tag) {
            case 0: {
              throw pb::InvalidProtocolBufferException.InvalidTag();
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              break;
            }
            case 10: {
              result.hasPropertyName = input.ReadString(ref result.propertyName_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasPropertyName {
        get { return result.hasPropertyName; }
      }
      public string PropertyName {
        get { return result.PropertyName; }
        set { SetPropertyName(value); }
      }
      public Builder SetPropertyName(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasPropertyName = true;
        result.propertyName_ = value;
        return this;
      }
      public Builder ClearPropertyName() {
        PrepareBuilder();
        result.hasPropertyName = false;
        result.propertyName_ = "";
        return this;
      }
    }
    static CSharpFieldOptions() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
    }
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class CSharpServiceOptions : pb::GeneratedMessage<CSharpServiceOptions, CSharpServiceOptions.Builder> {
    private CSharpServiceOptions() { }
    private static readonly CSharpServiceOptions defaultInstance = new CSharpServiceOptions().MakeReadOnly();
    private static readonly string[] _cSharpServiceOptionsFieldNames = new string[] { "interface_id" };
    private static readonly uint[] _cSharpServiceOptionsFieldTags = new uint[] { 10 };
    public static CSharpServiceOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CSharpServiceOptions DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override CSharpServiceOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpServiceOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CSharpServiceOptions, CSharpServiceOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable; }
    }
    
    public const int InterfaceIdFieldNumber = 1;
    private bool hasInterfaceId;
    private string interfaceId_ = "";
    public bool HasInterfaceId {
      get { return hasInterfaceId; }
    }
    public string InterfaceId {
      get { return interfaceId_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      CalcSerializedSize();
      string[] field_names = _cSharpServiceOptionsFieldNames;
      if (hasInterfaceId) {
        output.WriteString(1, field_names[0], InterfaceId);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        return CalcSerializedSize();
      }
    }
    
    private int CalcSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasInterfaceId) {
        size += pb::CodedOutputStream.ComputeStringSize(1, InterfaceId);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
    public static CSharpServiceOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CSharpServiceOptions ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CSharpServiceOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpServiceOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private CSharpServiceOptions MakeReadOnly() {
      return this;
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CSharpServiceOptions prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<CSharpServiceOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(CSharpServiceOptions cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private CSharpServiceOptions result;
      
      private CSharpServiceOptions PrepareBuilder() {
        if (resultIsReadOnly) {
          CSharpServiceOptions original = result;
          result = new CSharpServiceOptions();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override CSharpServiceOptions MessageBeingBuilt {
        get { return PrepareBuilder(); }
      }
      
      public override Builder Clear() {
        result = DefaultInstance;
        resultIsReadOnly = true;
        return this;
      }
      
      public override Builder Clone() {
        if (resultIsReadOnly) {
          return new Builder(result);
        } else {
          return new Builder().MergeFrom(result);
        }
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Descriptor; }
      }
      
      public override CSharpServiceOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.DefaultInstance; }
      }
      
      public override CSharpServiceOptions BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CSharpServiceOptions) {
          return MergeFrom((CSharpServiceOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CSharpServiceOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasInterfaceId) {
          InterfaceId = other.InterfaceId;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        PrepareBuilder();
        pb::UnknownFieldSet.Builder unknownFields = null;
        uint tag;
        string field_name;
        while (input.ReadTag(out tag, out field_name)) {
          if(tag == 0 && field_name != null) {
            int field_ordinal = global::System.Array.BinarySearch(_cSharpServiceOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _cSharpServiceOptionsFieldTags[field_ordinal];
            else {
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              continue;
            }
          }
          switch (tag) {
            case 0: {
              throw pb::InvalidProtocolBufferException.InvalidTag();
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              break;
            }
            case 10: {
              result.hasInterfaceId = input.ReadString(ref result.interfaceId_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasInterfaceId {
        get { return result.hasInterfaceId; }
      }
      public string InterfaceId {
        get { return result.InterfaceId; }
        set { SetInterfaceId(value); }
      }
      public Builder SetInterfaceId(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasInterfaceId = true;
        result.interfaceId_ = value;
        return this;
      }
      public Builder ClearInterfaceId() {
        PrepareBuilder();
        result.hasInterfaceId = false;
        result.interfaceId_ = "";
        return this;
      }
    }
    static CSharpServiceOptions() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
    }
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class CSharpMethodOptions : pb::GeneratedMessage<CSharpMethodOptions, CSharpMethodOptions.Builder> {
    private CSharpMethodOptions() { }
    private static readonly CSharpMethodOptions defaultInstance = new CSharpMethodOptions().MakeReadOnly();
    private static readonly string[] _cSharpMethodOptionsFieldNames = new string[] { "dispatch_id" };
    private static readonly uint[] _cSharpMethodOptionsFieldTags = new uint[] { 8 };
    public static CSharpMethodOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CSharpMethodOptions DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override CSharpMethodOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpMethodOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CSharpMethodOptions, CSharpMethodOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable; }
    }
    
    public const int DispatchIdFieldNumber = 1;
    private bool hasDispatchId;
    private int dispatchId_;
    public bool HasDispatchId {
      get { return hasDispatchId; }
    }
    public int DispatchId {
      get { return dispatchId_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      CalcSerializedSize();
      string[] field_names = _cSharpMethodOptionsFieldNames;
      if (hasDispatchId) {
        output.WriteInt32(1, field_names[0], DispatchId);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        return CalcSerializedSize();
      }
    }
    
    private int CalcSerializedSize() {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasDispatchId) {
        size += pb::CodedOutputStream.ComputeInt32Size(1, DispatchId);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
    public static CSharpMethodOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CSharpMethodOptions ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CSharpMethodOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpMethodOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private CSharpMethodOptions MakeReadOnly() {
      return this;
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CSharpMethodOptions prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<CSharpMethodOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(CSharpMethodOptions cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private CSharpMethodOptions result;
      
      private CSharpMethodOptions PrepareBuilder() {
        if (resultIsReadOnly) {
          CSharpMethodOptions original = result;
          result = new CSharpMethodOptions();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override CSharpMethodOptions MessageBeingBuilt {
        get { return PrepareBuilder(); }
      }
      
      public override Builder Clear() {
        result = DefaultInstance;
        resultIsReadOnly = true;
        return this;
      }
      
      public override Builder Clone() {
        if (resultIsReadOnly) {
          return new Builder(result);
        } else {
          return new Builder().MergeFrom(result);
        }
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Descriptor; }
      }
      
      public override CSharpMethodOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.DefaultInstance; }
      }
      
      public override CSharpMethodOptions BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CSharpMethodOptions) {
          return MergeFrom((CSharpMethodOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CSharpMethodOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasDispatchId) {
          DispatchId = other.DispatchId;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        PrepareBuilder();
        pb::UnknownFieldSet.Builder unknownFields = null;
        uint tag;
        string field_name;
        while (input.ReadTag(out tag, out field_name)) {
          if(tag == 0 && field_name != null) {
            int field_ordinal = global::System.Array.BinarySearch(_cSharpMethodOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _cSharpMethodOptionsFieldTags[field_ordinal];
            else {
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              continue;
            }
          }
          switch (tag) {
            case 0: {
              throw pb::InvalidProtocolBufferException.InvalidTag();
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
              break;
            }
            case 8: {
              result.hasDispatchId = input.ReadInt32(ref result.dispatchId_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasDispatchId {
        get { return result.hasDispatchId; }
      }
      public int DispatchId {
        get { return result.DispatchId; }
        set { SetDispatchId(value); }
      }
      public Builder SetDispatchId(int value) {
        PrepareBuilder();
        result.hasDispatchId = true;
        result.dispatchId_ = value;
        return this;
      }
      public Builder ClearDispatchId() {
        PrepareBuilder();
        result.hasDispatchId = false;
        result.dispatchId_ = 0;
        return this;
      }
    }
    static CSharpMethodOptions() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
    }
  }
  
  #endregion
  
}

#endregion Designer generated code