regenerate routeguide protos

2 files changed, 173 insertions, 121 deletions

diff --git a/examples/csharp/route_guide/RouteGuide/RouteGuide.cs b/examples/csharp/route_guide/RouteGuide/RouteGuide.cs
index 54cb823983..603809ee76 100644
--- a/examples/csharp/route_guide/RouteGuide/RouteGuide.cs
+++ b/examples/csharp/route_guide/RouteGuide/RouteGuide.cs
@@ -53,10 +53,10 @@ namespace Routeguide {
   }
   #region Messages
   /// <summary>
-  ///  Points are represented as latitude-longitude pairs in the E7 representation
-  ///  (degrees multiplied by 10**7 and rounded to the nearest integer).
-  ///  Latitudes should be in the range +/- 90 degrees and longitude should be in
-  ///  the range +/- 180 degrees (inclusive).
+  /// Points are represented as latitude-longitude pairs in the E7 representation
+  /// (degrees multiplied by 10**7 and rounded to the nearest integer).
+  /// Latitudes should be in the range +/- 90 degrees and longitude should be in
+  /// the range +/- 180 degrees (inclusive).
   /// </summary>
   public sealed partial class Point : pb::IMessage<Point> {
     private static readonly pb::MessageParser<Point> _parser = new pb::MessageParser<Point>(() => new Point());
@@ -204,8 +204,8 @@ namespace Routeguide {
   }
 
   /// <summary>
-  ///  A latitude-longitude rectangle, represented as two diagonally opposite
-  ///  points "lo" and "hi".
+  /// A latitude-longitude rectangle, represented as two diagonally opposite
+  /// points "lo" and "hi".
   /// </summary>
   public sealed partial class Rectangle : pb::IMessage<Rectangle> {
     private static readonly pb::MessageParser<Rectangle> _parser = new pb::MessageParser<Rectangle>(() => new Rectangle());
@@ -244,7 +244,7 @@ namespace Routeguide {
     public const int LoFieldNumber = 1;
     private global::Routeguide.Point lo_;
     /// <summary>
-    ///  One corner of the rectangle.
+    /// One corner of the rectangle.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public global::Routeguide.Point Lo {
@@ -258,7 +258,7 @@ namespace Routeguide {
     public const int HiFieldNumber = 2;
     private global::Routeguide.Point hi_;
     /// <summary>
-    ///  The other corner of the rectangle.
+    /// The other corner of the rectangle.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public global::Routeguide.Point Hi {
@@ -371,9 +371,9 @@ namespace Routeguide {
   }
 
   /// <summary>
-  ///  A feature names something at a given point.
+  /// A feature names something at a given point.
   ///
-  ///  If a feature could not be named, the name is empty.
+  /// If a feature could not be named, the name is empty.
   /// </summary>
   public sealed partial class Feature : pb::IMessage<Feature> {
     private static readonly pb::MessageParser<Feature> _parser = new pb::MessageParser<Feature>(() => new Feature());
@@ -412,7 +412,7 @@ namespace Routeguide {
     public const int NameFieldNumber = 1;
     private string name_ = "";
     /// <summary>
-    ///  The name of the feature.
+    /// The name of the feature.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public string Name {
@@ -426,7 +426,7 @@ namespace Routeguide {
     public const int LocationFieldNumber = 2;
     private global::Routeguide.Point location_;
     /// <summary>
-    ///  The point where the feature is detected.
+    /// The point where the feature is detected.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public global::Routeguide.Point Location {
@@ -533,7 +533,7 @@ namespace Routeguide {
   }
 
   /// <summary>
-  ///  A RouteNote is a message sent while at a given point.
+  /// A RouteNote is a message sent while at a given point.
   /// </summary>
   public sealed partial class RouteNote : pb::IMessage<RouteNote> {
     private static readonly pb::MessageParser<RouteNote> _parser = new pb::MessageParser<RouteNote>(() => new RouteNote());
@@ -572,7 +572,7 @@ namespace Routeguide {
     public const int LocationFieldNumber = 1;
     private global::Routeguide.Point location_;
     /// <summary>
-    ///  The location from which the message is sent.
+    /// The location from which the message is sent.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public global::Routeguide.Point Location {
@@ -586,7 +586,7 @@ namespace Routeguide {
     public const int MessageFieldNumber = 2;
     private string message_ = "";
     /// <summary>
-    ///  The message to be sent.
+    /// The message to be sent.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public string Message {
@@ -693,11 +693,11 @@ namespace Routeguide {
   }
 
   /// <summary>
-  ///  A RouteSummary is received in response to a RecordRoute rpc.
+  /// A RouteSummary is received in response to a RecordRoute rpc.
   ///
-  ///  It contains the number of individual points received, the number of
-  ///  detected features, and the total distance covered as the cumulative sum of
-  ///  the distance between each point.
+  /// It contains the number of individual points received, the number of
+  /// detected features, and the total distance covered as the cumulative sum of
+  /// the distance between each point.
   /// </summary>
   public sealed partial class RouteSummary : pb::IMessage<RouteSummary> {
     private static readonly pb::MessageParser<RouteSummary> _parser = new pb::MessageParser<RouteSummary>(() => new RouteSummary());
@@ -738,7 +738,7 @@ namespace Routeguide {
     public const int PointCountFieldNumber = 1;
     private int pointCount_;
     /// <summary>
-    ///  The number of points received.
+    /// The number of points received.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int PointCount {
@@ -752,7 +752,7 @@ namespace Routeguide {
     public const int FeatureCountFieldNumber = 2;
     private int featureCount_;
     /// <summary>
-    ///  The number of known features passed while traversing the route.
+    /// The number of known features passed while traversing the route.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int FeatureCount {
@@ -766,7 +766,7 @@ namespace Routeguide {
     public const int DistanceFieldNumber = 3;
     private int distance_;
     /// <summary>
-    ///  The distance covered in metres.
+    /// The distance covered in metres.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int Distance {
@@ -780,7 +780,7 @@ namespace Routeguide {
     public const int ElapsedTimeFieldNumber = 4;
     private int elapsedTime_;
     /// <summary>
-    ///  The duration of the traversal in seconds.
+    /// The duration of the traversal in seconds.
     /// </summary>
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int ElapsedTime {
diff --git a/examples/csharp/route_guide/RouteGuide/RouteGuideGrpc.cs b/examples/csharp/route_guide/RouteGuide/RouteGuideGrpc.cs
index eb70c8e2db..6f2d6bde62 100644
--- a/examples/csharp/route_guide/RouteGuide/RouteGuideGrpc.cs
+++ b/examples/csharp/route_guide/RouteGuide/RouteGuideGrpc.cs
@@ -35,45 +35,45 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using Grpc.Core;
+using grpc = global::Grpc.Core;
 
 namespace Routeguide {
   /// <summary>
-  ///  Interface exported by the server.
+  /// Interface exported by the server.
   /// </summary>
-  public static class RouteGuide
+  public static partial class RouteGuide
   {
     static readonly string __ServiceName = "routeguide.RouteGuide";
 
-    static readonly Marshaller<global::Routeguide.Point> __Marshaller_Point = Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Point.Parser.ParseFrom);
-    static readonly Marshaller<global::Routeguide.Feature> __Marshaller_Feature = Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Feature.Parser.ParseFrom);
-    static readonly Marshaller<global::Routeguide.Rectangle> __Marshaller_Rectangle = Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Rectangle.Parser.ParseFrom);
-    static readonly Marshaller<global::Routeguide.RouteSummary> __Marshaller_RouteSummary = Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.RouteSummary.Parser.ParseFrom);
-    static readonly Marshaller<global::Routeguide.RouteNote> __Marshaller_RouteNote = Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.RouteNote.Parser.ParseFrom);
+    static readonly grpc::Marshaller<global::Routeguide.Point> __Marshaller_Point = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Point.Parser.ParseFrom);
+    static readonly grpc::Marshaller<global::Routeguide.Feature> __Marshaller_Feature = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Feature.Parser.ParseFrom);
+    static readonly grpc::Marshaller<global::Routeguide.Rectangle> __Marshaller_Rectangle = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.Rectangle.Parser.ParseFrom);
+    static readonly grpc::Marshaller<global::Routeguide.RouteSummary> __Marshaller_RouteSummary = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.RouteSummary.Parser.ParseFrom);
+    static readonly grpc::Marshaller<global::Routeguide.RouteNote> __Marshaller_RouteNote = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Routeguide.RouteNote.Parser.ParseFrom);
 
-    static readonly Method<global::Routeguide.Point, global::Routeguide.Feature> __Method_GetFeature = new Method<global::Routeguide.Point, global::Routeguide.Feature>(
-        MethodType.Unary,
+    static readonly grpc::Method<global::Routeguide.Point, global::Routeguide.Feature> __Method_GetFeature = new grpc::Method<global::Routeguide.Point, global::Routeguide.Feature>(
+        grpc::MethodType.Unary,
         __ServiceName,
         "GetFeature",
         __Marshaller_Point,
         __Marshaller_Feature);
 
-    static readonly Method<global::Routeguide.Rectangle, global::Routeguide.Feature> __Method_ListFeatures = new Method<global::Routeguide.Rectangle, global::Routeguide.Feature>(
-        MethodType.ServerStreaming,
+    static readonly grpc::Method<global::Routeguide.Rectangle, global::Routeguide.Feature> __Method_ListFeatures = new grpc::Method<global::Routeguide.Rectangle, global::Routeguide.Feature>(
+        grpc::MethodType.ServerStreaming,
         __ServiceName,
         "ListFeatures",
         __Marshaller_Rectangle,
         __Marshaller_Feature);
 
-    static readonly Method<global::Routeguide.Point, global::Routeguide.RouteSummary> __Method_RecordRoute = new Method<global::Routeguide.Point, global::Routeguide.RouteSummary>(
-        MethodType.ClientStreaming,
+    static readonly grpc::Method<global::Routeguide.Point, global::Routeguide.RouteSummary> __Method_RecordRoute = new grpc::Method<global::Routeguide.Point, global::Routeguide.RouteSummary>(
+        grpc::MethodType.ClientStreaming,
         __ServiceName,
         "RecordRoute",
         __Marshaller_Point,
         __Marshaller_RouteSummary);
 
-    static readonly Method<global::Routeguide.RouteNote, global::Routeguide.RouteNote> __Method_RouteChat = new Method<global::Routeguide.RouteNote, global::Routeguide.RouteNote>(
-        MethodType.DuplexStreaming,
+    static readonly grpc::Method<global::Routeguide.RouteNote, global::Routeguide.RouteNote> __Method_RouteChat = new grpc::Method<global::Routeguide.RouteNote, global::Routeguide.RouteNote>(
+        grpc::MethodType.DuplexStreaming,
         __ServiceName,
         "RouteChat",
         __Marshaller_RouteNote,
@@ -86,69 +86,83 @@ namespace Routeguide {
     }
 
     /// <summary>Base class for server-side implementations of RouteGuide</summary>
-    public abstract class RouteGuideBase
+    public abstract partial class RouteGuideBase
     {
       /// <summary>
-      ///  A simple RPC.
+      /// A simple RPC.
       ///
-      ///  Obtains the feature at a given position.
+      /// Obtains the feature at a given position.
       ///
-      ///  A feature with an empty name is returned if there's no feature at the given
-      ///  position.
+      /// A feature with an empty name is returned if there's no feature at the given
+      /// position.
       /// </summary>
-      public virtual global::System.Threading.Tasks.Task<global::Routeguide.Feature> GetFeature(global::Routeguide.Point request, ServerCallContext context)
+      /// <param name="request">The request received from the client.</param>
+      /// <param name="context">The context of the server-side call handler being invoked.</param>
+      /// <returns>The response to send back to the client (wrapped by a task).</returns>
+      public virtual global::System.Threading.Tasks.Task<global::Routeguide.Feature> GetFeature(global::Routeguide.Point request, grpc::ServerCallContext context)
       {
-        throw new RpcException(new Status(StatusCode.Unimplemented, ""));
+        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
       }
 
       /// <summary>
-      ///  A server-to-client streaming RPC.
+      /// A server-to-client streaming RPC.
       ///
-      ///  Obtains the Features available within the given Rectangle.  Results are
-      ///  streamed rather than returned at once (e.g. in a response message with a
-      ///  repeated field), as the rectangle may cover a large area and contain a
-      ///  huge number of features.
+      /// Obtains the Features available within the given Rectangle.  Results are
+      /// streamed rather than returned at once (e.g. in a response message with a
+      /// repeated field), as the rectangle may cover a large area and contain a
+      /// huge number of features.
       /// </summary>
-      public virtual global::System.Threading.Tasks.Task ListFeatures(global::Routeguide.Rectangle request, IServerStreamWriter<global::Routeguide.Feature> responseStream, ServerCallContext context)
+      /// <param name="request">The request received from the client.</param>
+      /// <param name="responseStream">Used for sending responses back to the client.</param>
+      /// <param name="context">The context of the server-side call handler being invoked.</param>
+      /// <returns>A task indicating completion of the handler.</returns>
+      public virtual global::System.Threading.Tasks.Task ListFeatures(global::Routeguide.Rectangle request, grpc::IServerStreamWriter<global::Routeguide.Feature> responseStream, grpc::ServerCallContext context)
       {
-        throw new RpcException(new Status(StatusCode.Unimplemented, ""));
+        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
       }
 
       /// <summary>
-      ///  A client-to-server streaming RPC.
+      /// A client-to-server streaming RPC.
       ///
-      ///  Accepts a stream of Points on a route being traversed, returning a
-      ///  RouteSummary when traversal is completed.
+      /// Accepts a stream of Points on a route being traversed, returning a
+      /// RouteSummary when traversal is completed.
       /// </summary>
-      public virtual global::System.Threading.Tasks.Task<global::Routeguide.RouteSummary> RecordRoute(IAsyncStreamReader<global::Routeguide.Point> requestStream, ServerCallContext context)
+      /// <param name="requestStream">Used for reading requests from the client.</param>
+      /// <param name="context">The context of the server-side call handler being invoked.</param>
+      /// <returns>The response to send back to the client (wrapped by a task).</returns>
+      public virtual global::System.Threading.Tasks.Task<global::Routeguide.RouteSummary> RecordRoute(grpc::IAsyncStreamReader<global::Routeguide.Point> requestStream, grpc::ServerCallContext context)
       {
-        throw new RpcException(new Status(StatusCode.Unimplemented, ""));
+        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
       }
 
       /// <summary>
-      ///  A Bidirectional streaming RPC.
+      /// A Bidirectional streaming RPC.
       ///
-      ///  Accepts a stream of RouteNotes sent while a route is being traversed,
-      ///  while receiving other RouteNotes (e.g. from other users).
+      /// Accepts a stream of RouteNotes sent while a route is being traversed,
+      /// while receiving other RouteNotes (e.g. from other users).
       /// </summary>
-      public virtual global::System.Threading.Tasks.Task RouteChat(IAsyncStreamReader<global::Routeguide.RouteNote> requestStream, IServerStreamWriter<global::Routeguide.RouteNote> responseStream, ServerCallContext context)
+      /// <param name="requestStream">Used for reading requests from the client.</param>
+      /// <param name="responseStream">Used for sending responses back to the client.</param>
+      /// <param name="context">The context of the server-side call handler being invoked.</param>
+      /// <returns>A task indicating completion of the handler.</returns>
+      public virtual global::System.Threading.Tasks.Task RouteChat(grpc::IAsyncStreamReader<global::Routeguide.RouteNote> requestStream, grpc::IServerStreamWriter<global::Routeguide.RouteNote> responseStream, grpc::ServerCallContext context)
       {
-        throw new RpcException(new Status(StatusCode.Unimplemented, ""));
+        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
       }
 
     }
 
     /// <summary>Client for RouteGuide</summary>
-    public class RouteGuideClient : ClientBase<RouteGuideClient>
+    public partial class RouteGuideClient : grpc::ClientBase<RouteGuideClient>
     {
       /// <summary>Creates a new client for RouteGuide</summary>
       /// <param name="channel">The channel to use to make remote calls.</param>
-      public RouteGuideClient(Channel channel) : base(channel)
+      public RouteGuideClient(grpc::Channel channel) : base(channel)
       {
       }
       /// <summary>Creates a new client for RouteGuide that uses a custom <c>CallInvoker</c>.</summary>
       /// <param name="callInvoker">The callInvoker to use to make remote calls.</param>
-      public RouteGuideClient(CallInvoker callInvoker) : base(callInvoker)
+      public RouteGuideClient(grpc::CallInvoker callInvoker) : base(callInvoker)
       {
       }
       /// <summary>Protected parameterless constructor to allow creation of test doubles.</summary>
@@ -162,117 +176,154 @@ namespace Routeguide {
       }
 
       /// <summary>
-      ///  A simple RPC.
+      /// A simple RPC.
       ///
-      ///  Obtains the feature at a given position.
+      /// Obtains the feature at a given position.
       ///
-      ///  A feature with an empty name is returned if there's no feature at the given
-      ///  position.
+      /// A feature with an empty name is returned if there's no feature at the given
+      /// position.
       /// </summary>
-      public virtual global::Routeguide.Feature GetFeature(global::Routeguide.Point request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The response received from the server.</returns>
+      public virtual global::Routeguide.Feature GetFeature(global::Routeguide.Point request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
-        return GetFeature(request, new CallOptions(headers, deadline, cancellationToken));
+        return GetFeature(request, new grpc::CallOptions(headers, deadline, cancellationToken));
       }
       /// <summary>
-      ///  A simple RPC.
+      /// A simple RPC.
       ///
-      ///  Obtains the feature at a given position.
+      /// Obtains the feature at a given position.
       ///
-      ///  A feature with an empty name is returned if there's no feature at the given
-      ///  position.
+      /// A feature with an empty name is returned if there's no feature at the given
+      /// position.
       /// </summary>
-      public virtual global::Routeguide.Feature GetFeature(global::Routeguide.Point request, CallOptions options)
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The response received from the server.</returns>
+      public virtual global::Routeguide.Feature GetFeature(global::Routeguide.Point request, grpc::CallOptions options)
       {
         return CallInvoker.BlockingUnaryCall(__Method_GetFeature, null, options, request);
       }
       /// <summary>
-      ///  A simple RPC.
+      /// A simple RPC.
       ///
-      ///  Obtains the feature at a given position.
+      /// Obtains the feature at a given position.
       ///
-      ///  A feature with an empty name is returned if there's no feature at the given
-      ///  position.
+      /// A feature with an empty name is returned if there's no feature at the given
+      /// position.
       /// </summary>
-      public virtual AsyncUnaryCall<global::Routeguide.Feature> GetFeatureAsync(global::Routeguide.Point request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncUnaryCall<global::Routeguide.Feature> GetFeatureAsync(global::Routeguide.Point request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
-        return GetFeatureAsync(request, new CallOptions(headers, deadline, cancellationToken));
+        return GetFeatureAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
       }
       /// <summary>
-      ///  A simple RPC.
+      /// A simple RPC.
       ///
-      ///  Obtains the feature at a given position.
+      /// Obtains the feature at a given position.
       ///
-      ///  A feature with an empty name is returned if there's no feature at the given
-      ///  position.
+      /// A feature with an empty name is returned if there's no feature at the given
+      /// position.
       /// </summary>
-      public virtual AsyncUnaryCall<global::Routeguide.Feature> GetFeatureAsync(global::Routeguide.Point request, CallOptions options)
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncUnaryCall<global::Routeguide.Feature> GetFeatureAsync(global::Routeguide.Point request, grpc::CallOptions options)
       {
         return CallInvoker.AsyncUnaryCall(__Method_GetFeature, null, options, request);
       }
       /// <summary>
-      ///  A server-to-client streaming RPC.
+      /// A server-to-client streaming RPC.
       ///
-      ///  Obtains the Features available within the given Rectangle.  Results are
-      ///  streamed rather than returned at once (e.g. in a response message with a
-      ///  repeated field), as the rectangle may cover a large area and contain a
-      ///  huge number of features.
+      /// Obtains the Features available within the given Rectangle.  Results are
+      /// streamed rather than returned at once (e.g. in a response message with a
+      /// repeated field), as the rectangle may cover a large area and contain a
+      /// huge number of features.
       /// </summary>
-      public virtual AsyncServerStreamingCall<global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncServerStreamingCall<global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
-        return ListFeatures(request, new CallOptions(headers, deadline, cancellationToken));
+        return ListFeatures(request, new grpc::CallOptions(headers, deadline, cancellationToken));
       }
       /// <summary>
-      ///  A server-to-client streaming RPC.
+      /// A server-to-client streaming RPC.
       ///
-      ///  Obtains the Features available within the given Rectangle.  Results are
-      ///  streamed rather than returned at once (e.g. in a response message with a
-      ///  repeated field), as the rectangle may cover a large area and contain a
-      ///  huge number of features.
+      /// Obtains the Features available within the given Rectangle.  Results are
+      /// streamed rather than returned at once (e.g. in a response message with a
+      /// repeated field), as the rectangle may cover a large area and contain a
+      /// huge number of features.
       /// </summary>
-      public virtual AsyncServerStreamingCall<global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, CallOptions options)
+      /// <param name="request">The request to send to the server.</param>
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncServerStreamingCall<global::Routeguide.Feature> ListFeatures(global::Routeguide.Rectangle request, grpc::CallOptions options)
       {
         return CallInvoker.AsyncServerStreamingCall(__Method_ListFeatures, null, options, request);
       }
       /// <summary>
-      ///  A client-to-server streaming RPC.
+      /// A client-to-server streaming RPC.
       ///
-      ///  Accepts a stream of Points on a route being traversed, returning a
-      ///  RouteSummary when traversal is completed.
+      /// Accepts a stream of Points on a route being traversed, returning a
+      /// RouteSummary when traversal is completed.
       /// </summary>
-      public virtual AsyncClientStreamingCall<global::Routeguide.Point, global::Routeguide.RouteSummary> RecordRoute(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncClientStreamingCall<global::Routeguide.Point, global::Routeguide.RouteSummary> RecordRoute(grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
-        return RecordRoute(new CallOptions(headers, deadline, cancellationToken));
+        return RecordRoute(new grpc::CallOptions(headers, deadline, cancellationToken));
       }
       /// <summary>
-      ///  A client-to-server streaming RPC.
+      /// A client-to-server streaming RPC.
       ///
-      ///  Accepts a stream of Points on a route being traversed, returning a
-      ///  RouteSummary when traversal is completed.
+      /// Accepts a stream of Points on a route being traversed, returning a
+      /// RouteSummary when traversal is completed.
       /// </summary>
-      public virtual AsyncClientStreamingCall<global::Routeguide.Point, global::Routeguide.RouteSummary> RecordRoute(CallOptions options)
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncClientStreamingCall<global::Routeguide.Point, global::Routeguide.RouteSummary> RecordRoute(grpc::CallOptions options)
       {
         return CallInvoker.AsyncClientStreamingCall(__Method_RecordRoute, null, options);
       }
       /// <summary>
-      ///  A Bidirectional streaming RPC.
+      /// A Bidirectional streaming RPC.
       ///
-      ///  Accepts a stream of RouteNotes sent while a route is being traversed,
-      ///  while receiving other RouteNotes (e.g. from other users).
+      /// Accepts a stream of RouteNotes sent while a route is being traversed,
+      /// while receiving other RouteNotes (e.g. from other users).
       /// </summary>
-      public virtual AsyncDuplexStreamingCall<global::Routeguide.RouteNote, global::Routeguide.RouteNote> RouteChat(Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
+      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
+      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
+      /// <param name="cancellationToken">An optional token for canceling the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncDuplexStreamingCall<global::Routeguide.RouteNote, global::Routeguide.RouteNote> RouteChat(grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
       {
-        return RouteChat(new CallOptions(headers, deadline, cancellationToken));
+        return RouteChat(new grpc::CallOptions(headers, deadline, cancellationToken));
       }
       /// <summary>
-      ///  A Bidirectional streaming RPC.
+      /// A Bidirectional streaming RPC.
       ///
-      ///  Accepts a stream of RouteNotes sent while a route is being traversed,
-      ///  while receiving other RouteNotes (e.g. from other users).
+      /// Accepts a stream of RouteNotes sent while a route is being traversed,
+      /// while receiving other RouteNotes (e.g. from other users).
       /// </summary>
-      public virtual AsyncDuplexStreamingCall<global::Routeguide.RouteNote, global::Routeguide.RouteNote> RouteChat(CallOptions options)
+      /// <param name="options">The options for the call.</param>
+      /// <returns>The call object.</returns>
+      public virtual grpc::AsyncDuplexStreamingCall<global::Routeguide.RouteNote, global::Routeguide.RouteNote> RouteChat(grpc::CallOptions options)
       {
         return CallInvoker.AsyncDuplexStreamingCall(__Method_RouteChat, null, options);
       }
+      /// <summary>Creates a new instance of client from given <c>ClientBaseConfiguration</c>.</summary>
       protected override RouteGuideClient NewInstance(ClientBaseConfiguration configuration)
       {
         return new RouteGuideClient(configuration);
@@ -280,9 +331,10 @@ namespace Routeguide {
     }
 
     /// <summary>Creates service definition that can be registered with a server</summary>
-    public static ServerServiceDefinition BindService(RouteGuideBase serviceImpl)
+    /// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
+    public static grpc::ServerServiceDefinition BindService(RouteGuideBase serviceImpl)
     {
-      return ServerServiceDefinition.CreateBuilder()
+      return grpc::ServerServiceDefinition.CreateBuilder()
           .AddMethod(__Method_GetFeature, serviceImpl.GetFeature)
           .AddMethod(__Method_ListFeatures, serviceImpl.ListFeatures)
           .AddMethod(__Method_RecordRoute, serviceImpl.RecordRoute)