GroupsGrpc.cs

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

using grpc = global::Grpc.Core;

namespace Mruv.Groups {
  /// <summary>
  /// The MruV groups service provides procedures for managing groups.
  /// </summary>
  public static partial class MruVGroupsService
  {
    static readonly string __ServiceName = "mruv.groups.MruVGroupsService";

    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.Groups.CreateGroupRequest> __Marshaller_mruv_groups_CreateGroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.CreateGroupRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.CreateGroupResponse> __Marshaller_mruv_groups_CreateGroupResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.CreateGroupResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetGroupRequest> __Marshaller_mruv_groups_GetGroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetGroupRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetGroupResponse> __Marshaller_mruv_groups_GetGroupResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetGroupResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.UpdateGroupRequest> __Marshaller_mruv_groups_UpdateGroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.UpdateGroupRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.UpdateGroupResponse> __Marshaller_mruv_groups_UpdateGroupResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.UpdateGroupResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.DeleteGroupRequest> __Marshaller_mruv_groups_DeleteGroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.DeleteGroupRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.DeleteGroupResponse> __Marshaller_mruv_groups_DeleteGroupResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.DeleteGroupResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetGroupsRequest> __Marshaller_mruv_groups_GetGroupsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetGroupsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetGroupsResponse> __Marshaller_mruv_groups_GetGroupsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetGroupsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AssignOwnerRequest> __Marshaller_mruv_groups_AssignOwnerRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AssignOwnerRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AssignOwnerResponse> __Marshaller_mruv_groups_AssignOwnerResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AssignOwnerResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetOwnerRequest> __Marshaller_mruv_groups_GetOwnerRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetOwnerRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetOwnerResponse> __Marshaller_mruv_groups_GetOwnerResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetOwnerResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AddMemberRequest> __Marshaller_mruv_groups_AddMemberRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AddMemberRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AddMemberResponse> __Marshaller_mruv_groups_AddMemberResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AddMemberResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetMembersRequest> __Marshaller_mruv_groups_GetMembersRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetMembersRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetMembersResponse> __Marshaller_mruv_groups_GetMembersResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetMembersResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.RemoveMemberRequest> __Marshaller_mruv_groups_RemoveMemberRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.RemoveMemberRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.RemoveMemberResponse> __Marshaller_mruv_groups_RemoveMemberResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.RemoveMemberResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AddPermissionRequest> __Marshaller_mruv_groups_AddPermissionRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AddPermissionRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AddPermissionResponse> __Marshaller_mruv_groups_AddPermissionResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AddPermissionResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetPermissionsRequest> __Marshaller_mruv_groups_GetPermissionsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetPermissionsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetPermissionsResponse> __Marshaller_mruv_groups_GetPermissionsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetPermissionsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.RemovePermissionRequest> __Marshaller_mruv_groups_RemovePermissionRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.RemovePermissionRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.RemovePermissionResponse> __Marshaller_mruv_groups_RemovePermissionResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.RemovePermissionResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AddSubgroupRequest> __Marshaller_mruv_groups_AddSubgroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AddSubgroupRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.AddSubgroupResponse> __Marshaller_mruv_groups_AddSubgroupResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.AddSubgroupResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetSubgroupsRequest> __Marshaller_mruv_groups_GetSubgroupsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetSubgroupsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.GetSubgroupsResponse> __Marshaller_mruv_groups_GetSubgroupsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.GetSubgroupsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.RemoveSubgroupRequest> __Marshaller_mruv_groups_RemoveSubgroupRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.RemoveSubgroupRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.RemoveSubgroupResponse> __Marshaller_mruv_groups_RemoveSubgroupResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.RemoveSubgroupResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.IsPermittedRequest> __Marshaller_mruv_groups_IsPermittedRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.IsPermittedRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Groups.IsPermittedResponse> __Marshaller_mruv_groups_IsPermittedResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Groups.IsPermittedResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Common.ServiceStatusRequest> __Marshaller_mruv_common_ServiceStatusRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Common.ServiceStatusRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Common.ServiceStatusResponse> __Marshaller_mruv_common_ServiceStatusResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Common.ServiceStatusResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Common.VersionRequest> __Marshaller_mruv_common_VersionRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Common.VersionRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Common.VersionResponse> __Marshaller_mruv_common_VersionResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Common.VersionResponse.Parser));

    static readonly grpc::Method<global::Mruv.Groups.CreateGroupRequest, global::Mruv.Groups.CreateGroupResponse> __Method_CreateGroup = new grpc::Method<global::Mruv.Groups.CreateGroupRequest, global::Mruv.Groups.CreateGroupResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "CreateGroup",
        __Marshaller_mruv_groups_CreateGroupRequest,
        __Marshaller_mruv_groups_CreateGroupResponse);

    static readonly grpc::Method<global::Mruv.Groups.GetGroupRequest, global::Mruv.Groups.GetGroupResponse> __Method_GetGroup = new grpc::Method<global::Mruv.Groups.GetGroupRequest, global::Mruv.Groups.GetGroupResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetGroup",
        __Marshaller_mruv_groups_GetGroupRequest,
        __Marshaller_mruv_groups_GetGroupResponse);

    static readonly grpc::Method<global::Mruv.Groups.UpdateGroupRequest, global::Mruv.Groups.UpdateGroupResponse> __Method_UpdateGroup = new grpc::Method<global::Mruv.Groups.UpdateGroupRequest, global::Mruv.Groups.UpdateGroupResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "UpdateGroup",
        __Marshaller_mruv_groups_UpdateGroupRequest,
        __Marshaller_mruv_groups_UpdateGroupResponse);

    static readonly grpc::Method<global::Mruv.Groups.DeleteGroupRequest, global::Mruv.Groups.DeleteGroupResponse> __Method_DeleteGroup = new grpc::Method<global::Mruv.Groups.DeleteGroupRequest, global::Mruv.Groups.DeleteGroupResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "DeleteGroup",
        __Marshaller_mruv_groups_DeleteGroupRequest,
        __Marshaller_mruv_groups_DeleteGroupResponse);

    static readonly grpc::Method<global::Mruv.Groups.GetGroupsRequest, global::Mruv.Groups.GetGroupsResponse> __Method_GetGroups = new grpc::Method<global::Mruv.Groups.GetGroupsRequest, global::Mruv.Groups.GetGroupsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetGroups",
        __Marshaller_mruv_groups_GetGroupsRequest,
        __Marshaller_mruv_groups_GetGroupsResponse);

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

    static readonly grpc::Method<global::Mruv.Groups.GetOwnerRequest, global::Mruv.Groups.GetOwnerResponse> __Method_GetOwner = new grpc::Method<global::Mruv.Groups.GetOwnerRequest, global::Mruv.Groups.GetOwnerResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetOwner",
        __Marshaller_mruv_groups_GetOwnerRequest,
        __Marshaller_mruv_groups_GetOwnerResponse);

    static readonly grpc::Method<global::Mruv.Groups.AddMemberRequest, global::Mruv.Groups.AddMemberResponse> __Method_AddMember = new grpc::Method<global::Mruv.Groups.AddMemberRequest, global::Mruv.Groups.AddMemberResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "AddMember",
        __Marshaller_mruv_groups_AddMemberRequest,
        __Marshaller_mruv_groups_AddMemberResponse);

    static readonly grpc::Method<global::Mruv.Groups.GetMembersRequest, global::Mruv.Groups.GetMembersResponse> __Method_GetMembers = new grpc::Method<global::Mruv.Groups.GetMembersRequest, global::Mruv.Groups.GetMembersResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetMembers",
        __Marshaller_mruv_groups_GetMembersRequest,
        __Marshaller_mruv_groups_GetMembersResponse);

    static readonly grpc::Method<global::Mruv.Groups.RemoveMemberRequest, global::Mruv.Groups.RemoveMemberResponse> __Method_RemoveMember = new grpc::Method<global::Mruv.Groups.RemoveMemberRequest, global::Mruv.Groups.RemoveMemberResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "RemoveMember",
        __Marshaller_mruv_groups_RemoveMemberRequest,
        __Marshaller_mruv_groups_RemoveMemberResponse);

    static readonly grpc::Method<global::Mruv.Groups.AddPermissionRequest, global::Mruv.Groups.AddPermissionResponse> __Method_AddPermission = new grpc::Method<global::Mruv.Groups.AddPermissionRequest, global::Mruv.Groups.AddPermissionResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "AddPermission",
        __Marshaller_mruv_groups_AddPermissionRequest,
        __Marshaller_mruv_groups_AddPermissionResponse);

    static readonly grpc::Method<global::Mruv.Groups.GetPermissionsRequest, global::Mruv.Groups.GetPermissionsResponse> __Method_GetPermissions = new grpc::Method<global::Mruv.Groups.GetPermissionsRequest, global::Mruv.Groups.GetPermissionsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetPermissions",
        __Marshaller_mruv_groups_GetPermissionsRequest,
        __Marshaller_mruv_groups_GetPermissionsResponse);

    static readonly grpc::Method<global::Mruv.Groups.RemovePermissionRequest, global::Mruv.Groups.RemovePermissionResponse> __Method_RemovePermission = new grpc::Method<global::Mruv.Groups.RemovePermissionRequest, global::Mruv.Groups.RemovePermissionResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "RemovePermission",
        __Marshaller_mruv_groups_RemovePermissionRequest,
        __Marshaller_mruv_groups_RemovePermissionResponse);

    static readonly grpc::Method<global::Mruv.Groups.AddSubgroupRequest, global::Mruv.Groups.AddSubgroupResponse> __Method_AddSubgroup = new grpc::Method<global::Mruv.Groups.AddSubgroupRequest, global::Mruv.Groups.AddSubgroupResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "AddSubgroup",
        __Marshaller_mruv_groups_AddSubgroupRequest,
        __Marshaller_mruv_groups_AddSubgroupResponse);

    static readonly grpc::Method<global::Mruv.Groups.GetSubgroupsRequest, global::Mruv.Groups.GetSubgroupsResponse> __Method_GetSubgroups = new grpc::Method<global::Mruv.Groups.GetSubgroupsRequest, global::Mruv.Groups.GetSubgroupsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetSubgroups",
        __Marshaller_mruv_groups_GetSubgroupsRequest,
        __Marshaller_mruv_groups_GetSubgroupsResponse);

    static readonly grpc::Method<global::Mruv.Groups.RemoveSubgroupRequest, global::Mruv.Groups.RemoveSubgroupResponse> __Method_RemoveSubgroup = new grpc::Method<global::Mruv.Groups.RemoveSubgroupRequest, global::Mruv.Groups.RemoveSubgroupResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "RemoveSubgroup",
        __Marshaller_mruv_groups_RemoveSubgroupRequest,
        __Marshaller_mruv_groups_RemoveSubgroupResponse);

    static readonly grpc::Method<global::Mruv.Groups.IsPermittedRequest, global::Mruv.Groups.IsPermittedResponse> __Method_IsPermitted = new grpc::Method<global::Mruv.Groups.IsPermittedRequest, global::Mruv.Groups.IsPermittedResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "IsPermitted",
        __Marshaller_mruv_groups_IsPermittedRequest,
        __Marshaller_mruv_groups_IsPermittedResponse);

    static readonly grpc::Method<global::Mruv.Common.ServiceStatusRequest, global::Mruv.Common.ServiceStatusResponse> __Method_GetServiceStatus = new grpc::Method<global::Mruv.Common.ServiceStatusRequest, global::Mruv.Common.ServiceStatusResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetServiceStatus",
        __Marshaller_mruv_common_ServiceStatusRequest,
        __Marshaller_mruv_common_ServiceStatusResponse);

    static readonly grpc::Method<global::Mruv.Common.VersionRequest, global::Mruv.Common.VersionResponse> __Method_GetServiceVersion = new grpc::Method<global::Mruv.Common.VersionRequest, global::Mruv.Common.VersionResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetServiceVersion",
        __Marshaller_mruv_common_VersionRequest,
        __Marshaller_mruv_common_VersionResponse);

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

    /// <summary>Base class for server-side implementations of MruVGroupsService</summary>
    [grpc::BindServiceMethod(typeof(MruVGroupsService), "BindService")]
    public abstract partial class MruVGroupsServiceBase
    {
      /// <summary>
      /// Create a group.
      /// </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.Groups.CreateGroupResponse> CreateGroup(global::Mruv.Groups.CreateGroupRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get a  group.
      /// </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.Groups.GetGroupResponse> GetGroup(global::Mruv.Groups.GetGroupRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Update a group.
      /// </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.Groups.UpdateGroupResponse> UpdateGroup(global::Mruv.Groups.UpdateGroupRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete a group.
      /// </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.Groups.DeleteGroupResponse> DeleteGroup(global::Mruv.Groups.DeleteGroupRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get all groups.
      /// </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.Groups.GetGroupsResponse> GetGroups(global::Mruv.Groups.GetGroupsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Assign an owner. Group can have only one owner. Owner can be a player, a group or an account.
      /// </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.Groups.AssignOwnerResponse> AssignOwner(global::Mruv.Groups.AssignOwnerRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get group 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.Groups.GetOwnerResponse> GetOwner(global::Mruv.Groups.GetOwnerRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Add a group member.
      /// </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.Groups.AddMemberResponse> AddMember(global::Mruv.Groups.AddMemberRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get a group member.
      /// </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.Groups.GetMembersResponse> GetMembers(global::Mruv.Groups.GetMembersRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Remove a group member.
      /// </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.Groups.RemoveMemberResponse> RemoveMember(global::Mruv.Groups.RemoveMemberRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Add a permission to a group.
      /// </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.Groups.AddPermissionResponse> AddPermission(global::Mruv.Groups.AddPermissionRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get all group permissions.
      /// </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.Groups.GetPermissionsResponse> GetPermissions(global::Mruv.Groups.GetPermissionsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Remove group permission.
      /// </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.Groups.RemovePermissionResponse> RemovePermission(global::Mruv.Groups.RemovePermissionRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Add a subgroup to a group.
      /// </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.Groups.AddSubgroupResponse> AddSubgroup(global::Mruv.Groups.AddSubgroupRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get all subgroups.
      /// </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.Groups.GetSubgroupsResponse> GetSubgroups(global::Mruv.Groups.GetSubgroupsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Remove a subgroup from group.
      /// </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.Groups.RemoveSubgroupResponse> RemoveSubgroup(global::Mruv.Groups.RemoveSubgroupRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Check is member of a group is permitted to do specific action.
      /// </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.Groups.IsPermittedResponse> IsPermitted(global::Mruv.Groups.IsPermittedRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      ///Service status
      /// </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.Common.ServiceStatusResponse> GetServiceStatus(global::Mruv.Common.ServiceStatusRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      public virtual global::System.Threading.Tasks.Task<global::Mruv.Common.VersionResponse> GetServiceVersion(global::Mruv.Common.VersionRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

    }

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

      /// <summary>
      /// Create a group.
      /// </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.Groups.CreateGroupResponse CreateGroup(global::Mruv.Groups.CreateGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateGroup(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create a group.
      /// </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.Groups.CreateGroupResponse CreateGroup(global::Mruv.Groups.CreateGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_CreateGroup, null, options, request);
      }
      /// <summary>
      /// Create a group.
      /// </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.Groups.CreateGroupResponse> CreateGroupAsync(global::Mruv.Groups.CreateGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateGroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create a group.
      /// </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.Groups.CreateGroupResponse> CreateGroupAsync(global::Mruv.Groups.CreateGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_CreateGroup, null, options, request);
      }
      /// <summary>
      /// Get a  group.
      /// </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.Groups.GetGroupResponse GetGroup(global::Mruv.Groups.GetGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetGroup(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a  group.
      /// </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.Groups.GetGroupResponse GetGroup(global::Mruv.Groups.GetGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetGroup, null, options, request);
      }
      /// <summary>
      /// Get a  group.
      /// </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.Groups.GetGroupResponse> GetGroupAsync(global::Mruv.Groups.GetGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetGroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a  group.
      /// </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.Groups.GetGroupResponse> GetGroupAsync(global::Mruv.Groups.GetGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetGroup, null, options, request);
      }
      /// <summary>
      /// Update a group.
      /// </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.Groups.UpdateGroupResponse UpdateGroup(global::Mruv.Groups.UpdateGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UpdateGroup(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Update a group.
      /// </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.Groups.UpdateGroupResponse UpdateGroup(global::Mruv.Groups.UpdateGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_UpdateGroup, null, options, request);
      }
      /// <summary>
      /// Update a group.
      /// </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.Groups.UpdateGroupResponse> UpdateGroupAsync(global::Mruv.Groups.UpdateGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UpdateGroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Update a group.
      /// </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.Groups.UpdateGroupResponse> UpdateGroupAsync(global::Mruv.Groups.UpdateGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_UpdateGroup, null, options, request);
      }
      /// <summary>
      /// Delete a group.
      /// </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.Groups.DeleteGroupResponse DeleteGroup(global::Mruv.Groups.DeleteGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteGroup(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete a group.
      /// </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.Groups.DeleteGroupResponse DeleteGroup(global::Mruv.Groups.DeleteGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_DeleteGroup, null, options, request);
      }
      /// <summary>
      /// Delete a group.
      /// </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.Groups.DeleteGroupResponse> DeleteGroupAsync(global::Mruv.Groups.DeleteGroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteGroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete a group.
      /// </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.Groups.DeleteGroupResponse> DeleteGroupAsync(global::Mruv.Groups.DeleteGroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_DeleteGroup, null, options, request);
      }
      /// <summary>
      /// Get all groups.
      /// </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.Groups.GetGroupsResponse GetGroups(global::Mruv.Groups.GetGroupsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetGroups(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all groups.
      /// </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.Groups.GetGroupsResponse GetGroups(global::Mruv.Groups.GetGroupsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetGroups, null, options, request);
      }
      /// <summary>
      /// Get all groups.
      /// </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.Groups.GetGroupsResponse> GetGroupsAsync(global::Mruv.Groups.GetGroupsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetGroupsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all groups.
      /// </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.Groups.GetGroupsResponse> GetGroupsAsync(global::Mruv.Groups.GetGroupsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetGroups, null, options, request);
      }
      /// <summary>
      /// Assign an owner. Group can have only one owner. Owner can be a player, a group or an account.
      /// </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.Groups.AssignOwnerResponse AssignOwner(global::Mruv.Groups.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 an owner. Group can have only one owner. Owner can be a player, a group or an account.
      /// </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.Groups.AssignOwnerResponse AssignOwner(global::Mruv.Groups.AssignOwnerRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_AssignOwner, null, options, request);
      }
      /// <summary>
      /// Assign an owner. Group can have only one owner. Owner can be a player, a group or an account.
      /// </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.Groups.AssignOwnerResponse> AssignOwnerAsync(global::Mruv.Groups.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 an owner. Group can have only one owner. Owner can be a player, a group or an account.
      /// </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.Groups.AssignOwnerResponse> AssignOwnerAsync(global::Mruv.Groups.AssignOwnerRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_AssignOwner, null, options, request);
      }
      /// <summary>
      /// Get group 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.Groups.GetOwnerResponse GetOwner(global::Mruv.Groups.GetOwnerRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetOwner(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get group 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.Groups.GetOwnerResponse GetOwner(global::Mruv.Groups.GetOwnerRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetOwner, null, options, request);
      }
      /// <summary>
      /// Get group 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.Groups.GetOwnerResponse> GetOwnerAsync(global::Mruv.Groups.GetOwnerRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetOwnerAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get group 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.Groups.GetOwnerResponse> GetOwnerAsync(global::Mruv.Groups.GetOwnerRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetOwner, null, options, request);
      }
      /// <summary>
      /// Add a group member.
      /// </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.Groups.AddMemberResponse AddMember(global::Mruv.Groups.AddMemberRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AddMember(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Add a group member.
      /// </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.Groups.AddMemberResponse AddMember(global::Mruv.Groups.AddMemberRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_AddMember, null, options, request);
      }
      /// <summary>
      /// Add a group member.
      /// </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.Groups.AddMemberResponse> AddMemberAsync(global::Mruv.Groups.AddMemberRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AddMemberAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Add a group member.
      /// </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.Groups.AddMemberResponse> AddMemberAsync(global::Mruv.Groups.AddMemberRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_AddMember, null, options, request);
      }
      /// <summary>
      /// Get a group member.
      /// </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.Groups.GetMembersResponse GetMembers(global::Mruv.Groups.GetMembersRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetMembers(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a group member.
      /// </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.Groups.GetMembersResponse GetMembers(global::Mruv.Groups.GetMembersRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetMembers, null, options, request);
      }
      /// <summary>
      /// Get a group member.
      /// </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.Groups.GetMembersResponse> GetMembersAsync(global::Mruv.Groups.GetMembersRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetMembersAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a group member.
      /// </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.Groups.GetMembersResponse> GetMembersAsync(global::Mruv.Groups.GetMembersRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetMembers, null, options, request);
      }
      /// <summary>
      /// Remove a group member.
      /// </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.Groups.RemoveMemberResponse RemoveMember(global::Mruv.Groups.RemoveMemberRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return RemoveMember(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Remove a group member.
      /// </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.Groups.RemoveMemberResponse RemoveMember(global::Mruv.Groups.RemoveMemberRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_RemoveMember, null, options, request);
      }
      /// <summary>
      /// Remove a group member.
      /// </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.Groups.RemoveMemberResponse> RemoveMemberAsync(global::Mruv.Groups.RemoveMemberRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return RemoveMemberAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Remove a group member.
      /// </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.Groups.RemoveMemberResponse> RemoveMemberAsync(global::Mruv.Groups.RemoveMemberRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_RemoveMember, null, options, request);
      }
      /// <summary>
      /// Add a permission to a group.
      /// </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.Groups.AddPermissionResponse AddPermission(global::Mruv.Groups.AddPermissionRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AddPermission(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Add a permission to a group.
      /// </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.Groups.AddPermissionResponse AddPermission(global::Mruv.Groups.AddPermissionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_AddPermission, null, options, request);
      }
      /// <summary>
      /// Add a permission to a group.
      /// </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.Groups.AddPermissionResponse> AddPermissionAsync(global::Mruv.Groups.AddPermissionRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AddPermissionAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Add a permission to a group.
      /// </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.Groups.AddPermissionResponse> AddPermissionAsync(global::Mruv.Groups.AddPermissionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_AddPermission, null, options, request);
      }
      /// <summary>
      /// Get all group permissions.
      /// </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.Groups.GetPermissionsResponse GetPermissions(global::Mruv.Groups.GetPermissionsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetPermissions(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all group permissions.
      /// </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.Groups.GetPermissionsResponse GetPermissions(global::Mruv.Groups.GetPermissionsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetPermissions, null, options, request);
      }
      /// <summary>
      /// Get all group permissions.
      /// </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.Groups.GetPermissionsResponse> GetPermissionsAsync(global::Mruv.Groups.GetPermissionsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetPermissionsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all group permissions.
      /// </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.Groups.GetPermissionsResponse> GetPermissionsAsync(global::Mruv.Groups.GetPermissionsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetPermissions, null, options, request);
      }
      /// <summary>
      /// Remove group permission.
      /// </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.Groups.RemovePermissionResponse RemovePermission(global::Mruv.Groups.RemovePermissionRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return RemovePermission(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Remove group permission.
      /// </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.Groups.RemovePermissionResponse RemovePermission(global::Mruv.Groups.RemovePermissionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_RemovePermission, null, options, request);
      }
      /// <summary>
      /// Remove group permission.
      /// </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.Groups.RemovePermissionResponse> RemovePermissionAsync(global::Mruv.Groups.RemovePermissionRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return RemovePermissionAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Remove group permission.
      /// </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.Groups.RemovePermissionResponse> RemovePermissionAsync(global::Mruv.Groups.RemovePermissionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_RemovePermission, null, options, request);
      }
      /// <summary>
      /// Add a subgroup to a group.
      /// </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.Groups.AddSubgroupResponse AddSubgroup(global::Mruv.Groups.AddSubgroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AddSubgroup(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Add a subgroup to a group.
      /// </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.Groups.AddSubgroupResponse AddSubgroup(global::Mruv.Groups.AddSubgroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_AddSubgroup, null, options, request);
      }
      /// <summary>
      /// Add a subgroup to a group.
      /// </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.Groups.AddSubgroupResponse> AddSubgroupAsync(global::Mruv.Groups.AddSubgroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return AddSubgroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Add a subgroup to a group.
      /// </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.Groups.AddSubgroupResponse> AddSubgroupAsync(global::Mruv.Groups.AddSubgroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_AddSubgroup, null, options, request);
      }
      /// <summary>
      /// Get all subgroups.
      /// </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.Groups.GetSubgroupsResponse GetSubgroups(global::Mruv.Groups.GetSubgroupsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetSubgroups(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all subgroups.
      /// </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.Groups.GetSubgroupsResponse GetSubgroups(global::Mruv.Groups.GetSubgroupsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetSubgroups, null, options, request);
      }
      /// <summary>
      /// Get all subgroups.
      /// </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.Groups.GetSubgroupsResponse> GetSubgroupsAsync(global::Mruv.Groups.GetSubgroupsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetSubgroupsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all subgroups.
      /// </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.Groups.GetSubgroupsResponse> GetSubgroupsAsync(global::Mruv.Groups.GetSubgroupsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetSubgroups, null, options, request);
      }
      /// <summary>
      /// Remove a subgroup from group.
      /// </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.Groups.RemoveSubgroupResponse RemoveSubgroup(global::Mruv.Groups.RemoveSubgroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return RemoveSubgroup(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Remove a subgroup from group.
      /// </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.Groups.RemoveSubgroupResponse RemoveSubgroup(global::Mruv.Groups.RemoveSubgroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_RemoveSubgroup, null, options, request);
      }
      /// <summary>
      /// Remove a subgroup from group.
      /// </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.Groups.RemoveSubgroupResponse> RemoveSubgroupAsync(global::Mruv.Groups.RemoveSubgroupRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return RemoveSubgroupAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Remove a subgroup from group.
      /// </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.Groups.RemoveSubgroupResponse> RemoveSubgroupAsync(global::Mruv.Groups.RemoveSubgroupRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_RemoveSubgroup, null, options, request);
      }
      /// <summary>
      /// Check is member of a group is permitted to do specific action.
      /// </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.Groups.IsPermittedResponse IsPermitted(global::Mruv.Groups.IsPermittedRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return IsPermitted(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Check is member of a group is permitted to do specific action.
      /// </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.Groups.IsPermittedResponse IsPermitted(global::Mruv.Groups.IsPermittedRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_IsPermitted, null, options, request);
      }
      /// <summary>
      /// Check is member of a group is permitted to do specific action.
      /// </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.Groups.IsPermittedResponse> IsPermittedAsync(global::Mruv.Groups.IsPermittedRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return IsPermittedAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Check is member of a group is permitted to do specific action.
      /// </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.Groups.IsPermittedResponse> IsPermittedAsync(global::Mruv.Groups.IsPermittedRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_IsPermitted, null, options, request);
      }
      /// <summary>
      ///Service status
      /// </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.Common.ServiceStatusResponse GetServiceStatus(global::Mruv.Common.ServiceStatusRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetServiceStatus(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      ///Service status
      /// </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.Common.ServiceStatusResponse GetServiceStatus(global::Mruv.Common.ServiceStatusRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetServiceStatus, null, options, request);
      }
      /// <summary>
      ///Service status
      /// </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.Common.ServiceStatusResponse> GetServiceStatusAsync(global::Mruv.Common.ServiceStatusRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetServiceStatusAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      ///Service status
      /// </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.Common.ServiceStatusResponse> GetServiceStatusAsync(global::Mruv.Common.ServiceStatusRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetServiceStatus, null, options, request);
      }
      public virtual global::Mruv.Common.VersionResponse GetServiceVersion(global::Mruv.Common.VersionRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetServiceVersion(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      public virtual global::Mruv.Common.VersionResponse GetServiceVersion(global::Mruv.Common.VersionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetServiceVersion, null, options, request);
      }
      public virtual grpc::AsyncUnaryCall<global::Mruv.Common.VersionResponse> GetServiceVersionAsync(global::Mruv.Common.VersionRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetServiceVersionAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      public virtual grpc::AsyncUnaryCall<global::Mruv.Common.VersionResponse> GetServiceVersionAsync(global::Mruv.Common.VersionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetServiceVersion, null, options, request);
      }
      /// <summary>Creates a new instance of client from given <c>ClientBaseConfiguration</c>.</summary>
      protected override MruVGroupsServiceClient NewInstance(ClientBaseConfiguration configuration)
      {
        return new MruVGroupsServiceClient(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(MruVGroupsServiceBase serviceImpl)
    {
      return grpc::ServerServiceDefinition.CreateBuilder()
          .AddMethod(__Method_CreateGroup, serviceImpl.CreateGroup)
          .AddMethod(__Method_GetGroup, serviceImpl.GetGroup)
          .AddMethod(__Method_UpdateGroup, serviceImpl.UpdateGroup)
          .AddMethod(__Method_DeleteGroup, serviceImpl.DeleteGroup)
          .AddMethod(__Method_GetGroups, serviceImpl.GetGroups)
          .AddMethod(__Method_AssignOwner, serviceImpl.AssignOwner)
          .AddMethod(__Method_GetOwner, serviceImpl.GetOwner)
          .AddMethod(__Method_AddMember, serviceImpl.AddMember)
          .AddMethod(__Method_GetMembers, serviceImpl.GetMembers)
          .AddMethod(__Method_RemoveMember, serviceImpl.RemoveMember)
          .AddMethod(__Method_AddPermission, serviceImpl.AddPermission)
          .AddMethod(__Method_GetPermissions, serviceImpl.GetPermissions)
          .AddMethod(__Method_RemovePermission, serviceImpl.RemovePermission)
          .AddMethod(__Method_AddSubgroup, serviceImpl.AddSubgroup)
          .AddMethod(__Method_GetSubgroups, serviceImpl.GetSubgroups)
          .AddMethod(__Method_RemoveSubgroup, serviceImpl.RemoveSubgroup)
          .AddMethod(__Method_IsPermitted, serviceImpl.IsPermitted)
          .AddMethod(__Method_GetServiceStatus, serviceImpl.GetServiceStatus)
          .AddMethod(__Method_GetServiceVersion, serviceImpl.GetServiceVersion).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, MruVGroupsServiceBase serviceImpl)
    {
      serviceBinder.AddMethod(__Method_CreateGroup, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.CreateGroupRequest, global::Mruv.Groups.CreateGroupResponse>(serviceImpl.CreateGroup));
      serviceBinder.AddMethod(__Method_GetGroup, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.GetGroupRequest, global::Mruv.Groups.GetGroupResponse>(serviceImpl.GetGroup));
      serviceBinder.AddMethod(__Method_UpdateGroup, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.UpdateGroupRequest, global::Mruv.Groups.UpdateGroupResponse>(serviceImpl.UpdateGroup));
      serviceBinder.AddMethod(__Method_DeleteGroup, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.DeleteGroupRequest, global::Mruv.Groups.DeleteGroupResponse>(serviceImpl.DeleteGroup));
      serviceBinder.AddMethod(__Method_GetGroups, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.GetGroupsRequest, global::Mruv.Groups.GetGroupsResponse>(serviceImpl.GetGroups));
      serviceBinder.AddMethod(__Method_AssignOwner, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.AssignOwnerRequest, global::Mruv.Groups.AssignOwnerResponse>(serviceImpl.AssignOwner));
      serviceBinder.AddMethod(__Method_GetOwner, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.GetOwnerRequest, global::Mruv.Groups.GetOwnerResponse>(serviceImpl.GetOwner));
      serviceBinder.AddMethod(__Method_AddMember, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.AddMemberRequest, global::Mruv.Groups.AddMemberResponse>(serviceImpl.AddMember));
      serviceBinder.AddMethod(__Method_GetMembers, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.GetMembersRequest, global::Mruv.Groups.GetMembersResponse>(serviceImpl.GetMembers));
      serviceBinder.AddMethod(__Method_RemoveMember, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.RemoveMemberRequest, global::Mruv.Groups.RemoveMemberResponse>(serviceImpl.RemoveMember));
      serviceBinder.AddMethod(__Method_AddPermission, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.AddPermissionRequest, global::Mruv.Groups.AddPermissionResponse>(serviceImpl.AddPermission));
      serviceBinder.AddMethod(__Method_GetPermissions, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.GetPermissionsRequest, global::Mruv.Groups.GetPermissionsResponse>(serviceImpl.GetPermissions));
      serviceBinder.AddMethod(__Method_RemovePermission, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.RemovePermissionRequest, global::Mruv.Groups.RemovePermissionResponse>(serviceImpl.RemovePermission));
      serviceBinder.AddMethod(__Method_AddSubgroup, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.AddSubgroupRequest, global::Mruv.Groups.AddSubgroupResponse>(serviceImpl.AddSubgroup));
      serviceBinder.AddMethod(__Method_GetSubgroups, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.GetSubgroupsRequest, global::Mruv.Groups.GetSubgroupsResponse>(serviceImpl.GetSubgroups));
      serviceBinder.AddMethod(__Method_RemoveSubgroup, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.RemoveSubgroupRequest, global::Mruv.Groups.RemoveSubgroupResponse>(serviceImpl.RemoveSubgroup));
      serviceBinder.AddMethod(__Method_IsPermitted, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Groups.IsPermittedRequest, global::Mruv.Groups.IsPermittedResponse>(serviceImpl.IsPermitted));
      serviceBinder.AddMethod(__Method_GetServiceStatus, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Common.ServiceStatusRequest, global::Mruv.Common.ServiceStatusResponse>(serviceImpl.GetServiceStatus));
      serviceBinder.AddMethod(__Method_GetServiceVersion, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Common.VersionRequest, global::Mruv.Common.VersionResponse>(serviceImpl.GetServiceVersion));
    }

  }
}
#endregion