BusinessGrpc.cs

// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: business/business.proto
// </auto-generated>
#pragma warning disable 0414, 1591
#region Designer generated code

using grpc = global::Grpc.Core;

namespace Mruv.Business {
  /// <summary>
  /// The MruV business service provides procedures for managing businesses.
  /// Business can be owned by a player or organisation. Every business have it's own group and products to sell.
  /// Business can have rights to an estates.
  /// Every business has its own type and depends on it, business provides different services.
  /// </summary>
  public static partial class MruVBusinessService
  {
    static readonly string __ServiceName = "mruv.business.MruVBusinessService";

    static void __Helper_SerializeMessage(global::Google.Protobuf.IMessage message, grpc::SerializationContext context)
    {
      #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION
      if (message is global::Google.Protobuf.IBufferMessage)
      {
        context.SetPayloadLength(message.CalculateSize());
        global::Google.Protobuf.MessageExtensions.WriteTo(message, context.GetBufferWriter());
        context.Complete();
        return;
      }
      #endif
      context.Complete(global::Google.Protobuf.MessageExtensions.ToByteArray(message));
    }

    static class __Helper_MessageCache<T>
    {
      public static readonly bool IsBufferMessage = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(global::Google.Protobuf.IBufferMessage)).IsAssignableFrom(typeof(T));
    }

    static T __Helper_DeserializeMessage<T>(grpc::DeserializationContext context, global::Google.Protobuf.MessageParser<T> parser) where T : global::Google.Protobuf.IMessage<T>
    {
      #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION
      if (__Helper_MessageCache<T>.IsBufferMessage)
      {
        return parser.ParseFrom(context.PayloadAsReadOnlySequence());
      }
      #endif
      return parser.ParseFrom(context.PayloadAsNewBuffer());
    }

    static readonly grpc::Marshaller<global::Mruv.Business.CreateBusinessRequest> __Marshaller_mruv_business_CreateBusinessRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.CreateBusinessRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.CreateBusinessResponse> __Marshaller_mruv_business_CreateBusinessResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.CreateBusinessResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.GetBusinessRequest> __Marshaller_mruv_business_GetBusinessRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.GetBusinessRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.Business> __Marshaller_mruv_business_Business = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.Business.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.UpdateBusinessRequest> __Marshaller_mruv_business_UpdateBusinessRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.UpdateBusinessRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.DeleteBusinessRequest> __Marshaller_mruv_business_DeleteBusinessRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.DeleteBusinessRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.DeleteBusinessResponse> __Marshaller_mruv_business_DeleteBusinessResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.DeleteBusinessResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.AssignOwnerRequest> __Marshaller_mruv_business_AssignOwnerRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.AssignOwnerRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.AssignOwnerResponse> __Marshaller_mruv_business_AssignOwnerResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.AssignOwnerResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.AssignEstateRequest> __Marshaller_mruv_business_AssignEstateRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.AssignEstateRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.AssignEstateResponse> __Marshaller_mruv_business_AssignEstateResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.AssignEstateResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.UnassignEstateRequest> __Marshaller_mruv_business_UnassignEstateRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.UnassignEstateRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.UnassignEstateResponse> __Marshaller_mruv_business_UnassignEstateResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.UnassignEstateResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.BuyBusinessRequest> __Marshaller_mruv_business_BuyBusinessRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.BuyBusinessRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.BuyBusinessResponse> __Marshaller_mruv_business_BuyBusinessResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.BuyBusinessResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.WatchBusinessRequest> __Marshaller_mruv_business_WatchBusinessRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.WatchBusinessRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.WatchBusinessResponse> __Marshaller_mruv_business_WatchBusinessResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.WatchBusinessResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.WatchBusinessesRequest> __Marshaller_mruv_business_WatchBusinessesRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.WatchBusinessesRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Business.WatchBusinessesResponse> __Marshaller_mruv_business_WatchBusinessesResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Business.WatchBusinessesResponse.Parser));

    static readonly grpc::Method<global::Mruv.Business.CreateBusinessRequest, global::Mruv.Business.CreateBusinessResponse> __Method_CreateBusiness = new grpc::Method<global::Mruv.Business.CreateBusinessRequest, global::Mruv.Business.CreateBusinessResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "CreateBusiness",
        __Marshaller_mruv_business_CreateBusinessRequest,
        __Marshaller_mruv_business_CreateBusinessResponse);

    static readonly grpc::Method<global::Mruv.Business.GetBusinessRequest, global::Mruv.Business.Business> __Method_GetBusiness = new grpc::Method<global::Mruv.Business.GetBusinessRequest, global::Mruv.Business.Business>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetBusiness",
        __Marshaller_mruv_business_GetBusinessRequest,
        __Marshaller_mruv_business_Business);

    static readonly grpc::Method<global::Mruv.Business.UpdateBusinessRequest, global::Mruv.Business.Business> __Method_UpdateBusiness = new grpc::Method<global::Mruv.Business.UpdateBusinessRequest, global::Mruv.Business.Business>(
        grpc::MethodType.Unary,
        __ServiceName,
        "UpdateBusiness",
        __Marshaller_mruv_business_UpdateBusinessRequest,
        __Marshaller_mruv_business_Business);

    static readonly grpc::Method<global::Mruv.Business.DeleteBusinessRequest, global::Mruv.Business.DeleteBusinessResponse> __Method_DeleteBusiness = new grpc::Method<global::Mruv.Business.DeleteBusinessRequest, global::Mruv.Business.DeleteBusinessResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "DeleteBusiness",
        __Marshaller_mruv_business_DeleteBusinessRequest,
        __Marshaller_mruv_business_DeleteBusinessResponse);

    static readonly grpc::Method<global::Mruv.Business.AssignOwnerRequest, global::Mruv.Business.AssignOwnerResponse> __Method_AssignOwner = new grpc::Method<global::Mruv.Business.AssignOwnerRequest, global::Mruv.Business.AssignOwnerResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "AssignOwner",
        __Marshaller_mruv_business_AssignOwnerRequest,
        __Marshaller_mruv_business_AssignOwnerResponse);

    static readonly grpc::Method<global::Mruv.Business.AssignEstateRequest, global::Mruv.Business.AssignEstateResponse> __Method_AssignEstate = new grpc::Method<global::Mruv.Business.AssignEstateRequest, global::Mruv.Business.AssignEstateResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "AssignEstate",
        __Marshaller_mruv_business_AssignEstateRequest,
        __Marshaller_mruv_business_AssignEstateResponse);

    static readonly grpc::Method<global::Mruv.Business.UnassignEstateRequest, global::Mruv.Business.UnassignEstateResponse> __Method_UnassignEstate = new grpc::Method<global::Mruv.Business.UnassignEstateRequest, global::Mruv.Business.UnassignEstateResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "UnassignEstate",
        __Marshaller_mruv_business_UnassignEstateRequest,
        __Marshaller_mruv_business_UnassignEstateResponse);

    static readonly grpc::Method<global::Mruv.Business.BuyBusinessRequest, global::Mruv.Business.BuyBusinessResponse> __Method_BuyBusiness = new grpc::Method<global::Mruv.Business.BuyBusinessRequest, global::Mruv.Business.BuyBusinessResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "BuyBusiness",
        __Marshaller_mruv_business_BuyBusinessRequest,
        __Marshaller_mruv_business_BuyBusinessResponse);

    static readonly grpc::Method<global::Mruv.Business.WatchBusinessRequest, global::Mruv.Business.WatchBusinessResponse> __Method_WatchBusiness = new grpc::Method<global::Mruv.Business.WatchBusinessRequest, global::Mruv.Business.WatchBusinessResponse>(
        grpc::MethodType.ServerStreaming,
        __ServiceName,
        "WatchBusiness",
        __Marshaller_mruv_business_WatchBusinessRequest,
        __Marshaller_mruv_business_WatchBusinessResponse);

    static readonly grpc::Method<global::Mruv.Business.WatchBusinessesRequest, global::Mruv.Business.WatchBusinessesResponse> __Method_WatchBusinesses = new grpc::Method<global::Mruv.Business.WatchBusinessesRequest, global::Mruv.Business.WatchBusinessesResponse>(
        grpc::MethodType.ServerStreaming,
        __ServiceName,
        "WatchBusinesses",
        __Marshaller_mruv_business_WatchBusinessesRequest,
        __Marshaller_mruv_business_WatchBusinessesResponse);

    /// <summary>Service descriptor</summary>
    public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
    {
      get { return global::Mruv.Business.BusinessReflection.Descriptor.Services[0]; }
    }

    /// <summary>Base class for server-side implementations of MruVBusinessService</summary>
    [grpc::BindServiceMethod(typeof(MruVBusinessService), "BindService")]
    public abstract partial class MruVBusinessServiceBase
    {
      /// <summary>
      /// Create a business.
      /// </summary>
      /// <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::Mruv.Business.CreateBusinessResponse> CreateBusiness(global::Mruv.Business.CreateBusinessRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get a business.
      /// </summary>
      /// <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::Mruv.Business.Business> GetBusiness(global::Mruv.Business.GetBusinessRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Update a business.
      /// </summary>
      /// <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::Mruv.Business.Business> UpdateBusiness(global::Mruv.Business.UpdateBusinessRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete a business.
      /// </summary>
      /// <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::Mruv.Business.DeleteBusinessResponse> DeleteBusiness(global::Mruv.Business.DeleteBusinessRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Assign a business owner.
      /// </summary>
      /// <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::Mruv.Business.AssignOwnerResponse> AssignOwner(global::Mruv.Business.AssignOwnerRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Assign an estate to a business.
      /// </summary>
      /// <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::Mruv.Business.AssignEstateResponse> AssignEstate(global::Mruv.Business.AssignEstateRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// </summary>
      /// <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::Mruv.Business.UnassignEstateResponse> UnassignEstate(global::Mruv.Business.UnassignEstateRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Buy a business.
      /// </summary>
      /// <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::Mruv.Business.BuyBusinessResponse> BuyBusiness(global::Mruv.Business.BuyBusinessRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Subscribe to business events.
      /// </summary>
      /// <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 WatchBusiness(global::Mruv.Business.WatchBusinessRequest request, grpc::IServerStreamWriter<global::Mruv.Business.WatchBusinessResponse> responseStream, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Subscribe to all businesses events.
      /// </summary>
      /// <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 WatchBusinesses(global::Mruv.Business.WatchBusinessesRequest request, grpc::IServerStreamWriter<global::Mruv.Business.WatchBusinessesResponse> responseStream, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

    }

    /// <summary>Client for MruVBusinessService</summary>
    public partial class MruVBusinessServiceClient : grpc::ClientBase<MruVBusinessServiceClient>
    {
      /// <summary>Creates a new client for MruVBusinessService</summary>
      /// <param name="channel">The channel to use to make remote calls.</param>
      public MruVBusinessServiceClient(grpc::ChannelBase channel) : base(channel)
      {
      }
      /// <summary>Creates a new client for MruVBusinessService that uses a custom <c>CallInvoker</c>.</summary>
      /// <param name="callInvoker">The callInvoker to use to make remote calls.</param>
      public MruVBusinessServiceClient(grpc::CallInvoker callInvoker) : base(callInvoker)
      {
      }
      /// <summary>Protected parameterless constructor to allow creation of test doubles.</summary>
      protected MruVBusinessServiceClient() : base()
      {
      }
      /// <summary>Protected constructor to allow creation of configured clients.</summary>
      /// <param name="configuration">The client configuration.</param>
      protected MruVBusinessServiceClient(ClientBaseConfiguration configuration) : base(configuration)
      {
      }

      /// <summary>
      /// Create a business.
      /// </summary>
      /// <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::Mruv.Business.CreateBusinessResponse CreateBusiness(global::Mruv.Business.CreateBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateBusiness(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create a business.
      /// </summary>
      /// <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::Mruv.Business.CreateBusinessResponse CreateBusiness(global::Mruv.Business.CreateBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_CreateBusiness, null, options, request);
      }
      /// <summary>
      /// Create a business.
      /// </summary>
      /// <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::Mruv.Business.CreateBusinessResponse> CreateBusinessAsync(global::Mruv.Business.CreateBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateBusinessAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create a business.
      /// </summary>
      /// <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::Mruv.Business.CreateBusinessResponse> CreateBusinessAsync(global::Mruv.Business.CreateBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_CreateBusiness, null, options, request);
      }
      /// <summary>
      /// Get a business.
      /// </summary>
      /// <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::Mruv.Business.Business GetBusiness(global::Mruv.Business.GetBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetBusiness(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a business.
      /// </summary>
      /// <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::Mruv.Business.Business GetBusiness(global::Mruv.Business.GetBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetBusiness, null, options, request);
      }
      /// <summary>
      /// Get a business.
      /// </summary>
      /// <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::Mruv.Business.Business> GetBusinessAsync(global::Mruv.Business.GetBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetBusinessAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a business.
      /// </summary>
      /// <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::Mruv.Business.Business> GetBusinessAsync(global::Mruv.Business.GetBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetBusiness, null, options, request);
      }
      /// <summary>
      /// Update a business.
      /// </summary>
      /// <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::Mruv.Business.Business UpdateBusiness(global::Mruv.Business.UpdateBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UpdateBusiness(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Update a business.
      /// </summary>
      /// <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::Mruv.Business.Business UpdateBusiness(global::Mruv.Business.UpdateBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_UpdateBusiness, null, options, request);
      }
      /// <summary>
      /// Update a business.
      /// </summary>
      /// <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::Mruv.Business.Business> UpdateBusinessAsync(global::Mruv.Business.UpdateBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UpdateBusinessAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Update a business.
      /// </summary>
      /// <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::Mruv.Business.Business> UpdateBusinessAsync(global::Mruv.Business.UpdateBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_UpdateBusiness, null, options, request);
      }
      /// <summary>
      /// Delete a business.
      /// </summary>
      /// <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::Mruv.Business.DeleteBusinessResponse DeleteBusiness(global::Mruv.Business.DeleteBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteBusiness(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete a business.
      /// </summary>
      /// <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::Mruv.Business.DeleteBusinessResponse DeleteBusiness(global::Mruv.Business.DeleteBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_DeleteBusiness, null, options, request);
      }
      /// <summary>
      /// Delete a business.
      /// </summary>
      /// <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::Mruv.Business.DeleteBusinessResponse> DeleteBusinessAsync(global::Mruv.Business.DeleteBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteBusinessAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete a business.
      /// </summary>
      /// <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::Mruv.Business.DeleteBusinessResponse> DeleteBusinessAsync(global::Mruv.Business.DeleteBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_DeleteBusiness, null, options, request);
      }
      /// <summary>
      /// Assign a business owner.
      /// </summary>
      /// <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::Mruv.Business.AssignOwnerResponse AssignOwner(global::Mruv.Business.AssignOwnerRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AssignOwner(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Assign a business owner.
      /// </summary>
      /// <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::Mruv.Business.AssignOwnerResponse AssignOwner(global::Mruv.Business.AssignOwnerRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_AssignOwner, null, options, request);
      }
      /// <summary>
      /// Assign a business owner.
      /// </summary>
      /// <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::Mruv.Business.AssignOwnerResponse> AssignOwnerAsync(global::Mruv.Business.AssignOwnerRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AssignOwnerAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Assign a business owner.
      /// </summary>
      /// <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::Mruv.Business.AssignOwnerResponse> AssignOwnerAsync(global::Mruv.Business.AssignOwnerRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_AssignOwner, null, options, request);
      }
      /// <summary>
      /// Assign an estate to a business.
      /// </summary>
      /// <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::Mruv.Business.AssignEstateResponse AssignEstate(global::Mruv.Business.AssignEstateRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AssignEstate(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Assign an estate to a business.
      /// </summary>
      /// <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::Mruv.Business.AssignEstateResponse AssignEstate(global::Mruv.Business.AssignEstateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_AssignEstate, null, options, request);
      }
      /// <summary>
      /// Assign an estate to a business.
      /// </summary>
      /// <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::Mruv.Business.AssignEstateResponse> AssignEstateAsync(global::Mruv.Business.AssignEstateRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AssignEstateAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Assign an estate to a business.
      /// </summary>
      /// <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::Mruv.Business.AssignEstateResponse> AssignEstateAsync(global::Mruv.Business.AssignEstateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_AssignEstate, null, options, request);
      }
      /// <summary>
      /// </summary>
      /// <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::Mruv.Business.UnassignEstateResponse UnassignEstate(global::Mruv.Business.UnassignEstateRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UnassignEstate(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// </summary>
      /// <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::Mruv.Business.UnassignEstateResponse UnassignEstate(global::Mruv.Business.UnassignEstateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_UnassignEstate, null, options, request);
      }
      /// <summary>
      /// </summary>
      /// <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::Mruv.Business.UnassignEstateResponse> UnassignEstateAsync(global::Mruv.Business.UnassignEstateRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UnassignEstateAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// </summary>
      /// <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::Mruv.Business.UnassignEstateResponse> UnassignEstateAsync(global::Mruv.Business.UnassignEstateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_UnassignEstate, null, options, request);
      }
      /// <summary>
      /// Buy a business.
      /// </summary>
      /// <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::Mruv.Business.BuyBusinessResponse BuyBusiness(global::Mruv.Business.BuyBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return BuyBusiness(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Buy a business.
      /// </summary>
      /// <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::Mruv.Business.BuyBusinessResponse BuyBusiness(global::Mruv.Business.BuyBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_BuyBusiness, null, options, request);
      }
      /// <summary>
      /// Buy a business.
      /// </summary>
      /// <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::Mruv.Business.BuyBusinessResponse> BuyBusinessAsync(global::Mruv.Business.BuyBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return BuyBusinessAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Buy a business.
      /// </summary>
      /// <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::Mruv.Business.BuyBusinessResponse> BuyBusinessAsync(global::Mruv.Business.BuyBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_BuyBusiness, null, options, request);
      }
      /// <summary>
      /// Subscribe to business events.
      /// </summary>
      /// <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::Mruv.Business.WatchBusinessResponse> WatchBusiness(global::Mruv.Business.WatchBusinessRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return WatchBusiness(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Subscribe to business events.
      /// </summary>
      /// <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::Mruv.Business.WatchBusinessResponse> WatchBusiness(global::Mruv.Business.WatchBusinessRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncServerStreamingCall(__Method_WatchBusiness, null, options, request);
      }
      /// <summary>
      /// Subscribe to all businesses events.
      /// </summary>
      /// <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::Mruv.Business.WatchBusinessesResponse> WatchBusinesses(global::Mruv.Business.WatchBusinessesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return WatchBusinesses(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Subscribe to all businesses events.
      /// </summary>
      /// <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::Mruv.Business.WatchBusinessesResponse> WatchBusinesses(global::Mruv.Business.WatchBusinessesRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncServerStreamingCall(__Method_WatchBusinesses, null, options, request);
      }
      /// <summary>Creates a new instance of client from given <c>ClientBaseConfiguration</c>.</summary>
      protected override MruVBusinessServiceClient NewInstance(ClientBaseConfiguration configuration)
      {
        return new MruVBusinessServiceClient(configuration);
      }
    }

    /// <summary>Creates service definition that can be registered with a server</summary>
    /// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
    public static grpc::ServerServiceDefinition BindService(MruVBusinessServiceBase serviceImpl)
    {
      return grpc::ServerServiceDefinition.CreateBuilder()
          .AddMethod(__Method_CreateBusiness, serviceImpl.CreateBusiness)
          .AddMethod(__Method_GetBusiness, serviceImpl.GetBusiness)
          .AddMethod(__Method_UpdateBusiness, serviceImpl.UpdateBusiness)
          .AddMethod(__Method_DeleteBusiness, serviceImpl.DeleteBusiness)
          .AddMethod(__Method_AssignOwner, serviceImpl.AssignOwner)
          .AddMethod(__Method_AssignEstate, serviceImpl.AssignEstate)
          .AddMethod(__Method_UnassignEstate, serviceImpl.UnassignEstate)
          .AddMethod(__Method_BuyBusiness, serviceImpl.BuyBusiness)
          .AddMethod(__Method_WatchBusiness, serviceImpl.WatchBusiness)
          .AddMethod(__Method_WatchBusinesses, serviceImpl.WatchBusinesses).Build();
    }

    /// <summary>Register service method with a service binder with or without implementation. Useful when customizing the  service binding logic.
    /// Note: this method is part of an experimental API that can change or be removed without any prior notice.</summary>
    /// <param name="serviceBinder">Service methods will be bound by calling <c>AddMethod</c> on this object.</param>
    /// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
    public static void BindService(grpc::ServiceBinderBase serviceBinder, MruVBusinessServiceBase serviceImpl)
    {
      serviceBinder.AddMethod(__Method_CreateBusiness, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.CreateBusinessRequest, global::Mruv.Business.CreateBusinessResponse>(serviceImpl.CreateBusiness));
      serviceBinder.AddMethod(__Method_GetBusiness, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.GetBusinessRequest, global::Mruv.Business.Business>(serviceImpl.GetBusiness));
      serviceBinder.AddMethod(__Method_UpdateBusiness, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.UpdateBusinessRequest, global::Mruv.Business.Business>(serviceImpl.UpdateBusiness));
      serviceBinder.AddMethod(__Method_DeleteBusiness, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.DeleteBusinessRequest, global::Mruv.Business.DeleteBusinessResponse>(serviceImpl.DeleteBusiness));
      serviceBinder.AddMethod(__Method_AssignOwner, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.AssignOwnerRequest, global::Mruv.Business.AssignOwnerResponse>(serviceImpl.AssignOwner));
      serviceBinder.AddMethod(__Method_AssignEstate, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.AssignEstateRequest, global::Mruv.Business.AssignEstateResponse>(serviceImpl.AssignEstate));
      serviceBinder.AddMethod(__Method_UnassignEstate, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.UnassignEstateRequest, global::Mruv.Business.UnassignEstateResponse>(serviceImpl.UnassignEstate));
      serviceBinder.AddMethod(__Method_BuyBusiness, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Business.BuyBusinessRequest, global::Mruv.Business.BuyBusinessResponse>(serviceImpl.BuyBusiness));
      serviceBinder.AddMethod(__Method_WatchBusiness, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod<global::Mruv.Business.WatchBusinessRequest, global::Mruv.Business.WatchBusinessResponse>(serviceImpl.WatchBusiness));
      serviceBinder.AddMethod(__Method_WatchBusinesses, serviceImpl == null ? null : new grpc::ServerStreamingServerMethod<global::Mruv.Business.WatchBusinessesRequest, global::Mruv.Business.WatchBusinessesResponse>(serviceImpl.WatchBusinesses));
    }

  }
}
#endregion