ItemsGrpc.cs

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

using grpc = global::Grpc.Core;

namespace Mruv.Items {
  /// <summary>
  /// The MruV items service provides procedures for managing items and containers
  /// </summary>
  public static partial class MruVItemService
  {
    static readonly string __ServiceName = "mruv.items.MruVItemService";

    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.Items.Item> __Marshaller_mruv_items_Item = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.Item.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.ItemID> __Marshaller_mruv_items_ItemID = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.ItemID.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetItemsRequest> __Marshaller_mruv_items_GetItemsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetItemsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetItemsResponse> __Marshaller_mruv_items_GetItemsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetItemsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.ItemType> __Marshaller_mruv_items_ItemType = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.ItemType.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.ItemTypeID> __Marshaller_mruv_items_ItemTypeID = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.ItemTypeID.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetItemTypesRequest> __Marshaller_mruv_items_GetItemTypesRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetItemTypesRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetItemTypesResponse> __Marshaller_mruv_items_GetItemTypesResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetItemTypesResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.Container> __Marshaller_mruv_items_Container = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.Container.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.ContainerID> __Marshaller_mruv_items_ContainerID = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.ContainerID.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetContainersRequest> __Marshaller_mruv_items_GetContainersRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetContainersRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetContainersResponse> __Marshaller_mruv_items_GetContainersResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetContainersResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.ContainerType> __Marshaller_mruv_items_ContainerType = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.ContainerType.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.ContainerTypeID> __Marshaller_mruv_items_ContainerTypeID = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.ContainerTypeID.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetContainerTypesRequest> __Marshaller_mruv_items_GetContainerTypesRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetContainerTypesRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetContainerTypesResponse> __Marshaller_mruv_items_GetContainerTypesResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetContainerTypesResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetContainerItemsRequest> __Marshaller_mruv_items_GetContainerItemsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetContainerItemsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetContainerItemsResponse> __Marshaller_mruv_items_GetContainerItemsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetContainerItemsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.PullItemRequest> __Marshaller_mruv_items_PullItemRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.PullItemRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.PutItemRequest> __Marshaller_mruv_items_PutItemRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.PutItemRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.PutItemResponse> __Marshaller_mruv_items_PutItemResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.PutItemResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.SortItemsRequest> __Marshaller_mruv_items_SortItemsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.SortItemsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.SortItemsResponse> __Marshaller_mruv_items_SortItemsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.SortItemsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetNearestItemsRequest> __Marshaller_mruv_items_GetNearestItemsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetNearestItemsRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.GetNearestItemsResponse> __Marshaller_mruv_items_GetNearestItemsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.GetNearestItemsResponse.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.UseItemRequest> __Marshaller_mruv_items_UseItemRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.UseItemRequest.Parser));
    static readonly grpc::Marshaller<global::Mruv.Items.UseItemResponse> __Marshaller_mruv_items_UseItemResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Mruv.Items.UseItemResponse.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.Items.Item, global::Mruv.Items.ItemID> __Method_CreateItem = new grpc::Method<global::Mruv.Items.Item, global::Mruv.Items.ItemID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "CreateItem",
        __Marshaller_mruv_items_Item,
        __Marshaller_mruv_items_ItemID);

    static readonly grpc::Method<global::Mruv.Items.ItemID, global::Mruv.Items.Item> __Method_GetItem = new grpc::Method<global::Mruv.Items.ItemID, global::Mruv.Items.Item>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetItem",
        __Marshaller_mruv_items_ItemID,
        __Marshaller_mruv_items_Item);

    static readonly grpc::Method<global::Mruv.Items.ItemID, global::Mruv.Items.ItemID> __Method_DeleteItem = new grpc::Method<global::Mruv.Items.ItemID, global::Mruv.Items.ItemID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "DeleteItem",
        __Marshaller_mruv_items_ItemID,
        __Marshaller_mruv_items_ItemID);

    static readonly grpc::Method<global::Mruv.Items.GetItemsRequest, global::Mruv.Items.GetItemsResponse> __Method_GetItems = new grpc::Method<global::Mruv.Items.GetItemsRequest, global::Mruv.Items.GetItemsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetItems",
        __Marshaller_mruv_items_GetItemsRequest,
        __Marshaller_mruv_items_GetItemsResponse);

    static readonly grpc::Method<global::Mruv.Items.ItemType, global::Mruv.Items.ItemTypeID> __Method_CreateItemType = new grpc::Method<global::Mruv.Items.ItemType, global::Mruv.Items.ItemTypeID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "CreateItemType",
        __Marshaller_mruv_items_ItemType,
        __Marshaller_mruv_items_ItemTypeID);

    static readonly grpc::Method<global::Mruv.Items.ItemTypeID, global::Mruv.Items.ItemType> __Method_GetItemType = new grpc::Method<global::Mruv.Items.ItemTypeID, global::Mruv.Items.ItemType>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetItemType",
        __Marshaller_mruv_items_ItemTypeID,
        __Marshaller_mruv_items_ItemType);

    static readonly grpc::Method<global::Mruv.Items.ItemTypeID, global::Mruv.Items.ItemTypeID> __Method_DeleteItemType = new grpc::Method<global::Mruv.Items.ItemTypeID, global::Mruv.Items.ItemTypeID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "DeleteItemType",
        __Marshaller_mruv_items_ItemTypeID,
        __Marshaller_mruv_items_ItemTypeID);

    static readonly grpc::Method<global::Mruv.Items.GetItemTypesRequest, global::Mruv.Items.GetItemTypesResponse> __Method_GetItemTypes = new grpc::Method<global::Mruv.Items.GetItemTypesRequest, global::Mruv.Items.GetItemTypesResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetItemTypes",
        __Marshaller_mruv_items_GetItemTypesRequest,
        __Marshaller_mruv_items_GetItemTypesResponse);

    static readonly grpc::Method<global::Mruv.Items.Container, global::Mruv.Items.ContainerID> __Method_CreateContainer = new grpc::Method<global::Mruv.Items.Container, global::Mruv.Items.ContainerID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "CreateContainer",
        __Marshaller_mruv_items_Container,
        __Marshaller_mruv_items_ContainerID);

    static readonly grpc::Method<global::Mruv.Items.ContainerID, global::Mruv.Items.Container> __Method_GetContainer = new grpc::Method<global::Mruv.Items.ContainerID, global::Mruv.Items.Container>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetContainer",
        __Marshaller_mruv_items_ContainerID,
        __Marshaller_mruv_items_Container);

    static readonly grpc::Method<global::Mruv.Items.ContainerID, global::Mruv.Items.ContainerID> __Method_DeleteContainer = new grpc::Method<global::Mruv.Items.ContainerID, global::Mruv.Items.ContainerID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "DeleteContainer",
        __Marshaller_mruv_items_ContainerID,
        __Marshaller_mruv_items_ContainerID);

    static readonly grpc::Method<global::Mruv.Items.GetContainersRequest, global::Mruv.Items.GetContainersResponse> __Method_GetContainers = new grpc::Method<global::Mruv.Items.GetContainersRequest, global::Mruv.Items.GetContainersResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetContainers",
        __Marshaller_mruv_items_GetContainersRequest,
        __Marshaller_mruv_items_GetContainersResponse);

    static readonly grpc::Method<global::Mruv.Items.ContainerType, global::Mruv.Items.ContainerTypeID> __Method_CreateContainerType = new grpc::Method<global::Mruv.Items.ContainerType, global::Mruv.Items.ContainerTypeID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "CreateContainerType",
        __Marshaller_mruv_items_ContainerType,
        __Marshaller_mruv_items_ContainerTypeID);

    static readonly grpc::Method<global::Mruv.Items.ContainerTypeID, global::Mruv.Items.ContainerType> __Method_GetContainerType = new grpc::Method<global::Mruv.Items.ContainerTypeID, global::Mruv.Items.ContainerType>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetContainerType",
        __Marshaller_mruv_items_ContainerTypeID,
        __Marshaller_mruv_items_ContainerType);

    static readonly grpc::Method<global::Mruv.Items.ContainerTypeID, global::Mruv.Items.ContainerTypeID> __Method_DeleteContainerType = new grpc::Method<global::Mruv.Items.ContainerTypeID, global::Mruv.Items.ContainerTypeID>(
        grpc::MethodType.Unary,
        __ServiceName,
        "DeleteContainerType",
        __Marshaller_mruv_items_ContainerTypeID,
        __Marshaller_mruv_items_ContainerTypeID);

    static readonly grpc::Method<global::Mruv.Items.GetContainerTypesRequest, global::Mruv.Items.GetContainerTypesResponse> __Method_GetContainerTypes = new grpc::Method<global::Mruv.Items.GetContainerTypesRequest, global::Mruv.Items.GetContainerTypesResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetContainerTypes",
        __Marshaller_mruv_items_GetContainerTypesRequest,
        __Marshaller_mruv_items_GetContainerTypesResponse);

    static readonly grpc::Method<global::Mruv.Items.GetContainerItemsRequest, global::Mruv.Items.GetContainerItemsResponse> __Method_GetContainerItems = new grpc::Method<global::Mruv.Items.GetContainerItemsRequest, global::Mruv.Items.GetContainerItemsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetContainerItems",
        __Marshaller_mruv_items_GetContainerItemsRequest,
        __Marshaller_mruv_items_GetContainerItemsResponse);

    static readonly grpc::Method<global::Mruv.Items.PullItemRequest, global::Mruv.Items.Item> __Method_PullItem = new grpc::Method<global::Mruv.Items.PullItemRequest, global::Mruv.Items.Item>(
        grpc::MethodType.Unary,
        __ServiceName,
        "PullItem",
        __Marshaller_mruv_items_PullItemRequest,
        __Marshaller_mruv_items_Item);

    static readonly grpc::Method<global::Mruv.Items.PutItemRequest, global::Mruv.Items.PutItemResponse> __Method_PutItem = new grpc::Method<global::Mruv.Items.PutItemRequest, global::Mruv.Items.PutItemResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "PutItem",
        __Marshaller_mruv_items_PutItemRequest,
        __Marshaller_mruv_items_PutItemResponse);

    static readonly grpc::Method<global::Mruv.Items.SortItemsRequest, global::Mruv.Items.SortItemsResponse> __Method_SortItems = new grpc::Method<global::Mruv.Items.SortItemsRequest, global::Mruv.Items.SortItemsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "SortItems",
        __Marshaller_mruv_items_SortItemsRequest,
        __Marshaller_mruv_items_SortItemsResponse);

    static readonly grpc::Method<global::Mruv.Items.GetNearestItemsRequest, global::Mruv.Items.GetNearestItemsResponse> __Method_GetNearestItems = new grpc::Method<global::Mruv.Items.GetNearestItemsRequest, global::Mruv.Items.GetNearestItemsResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetNearestItems",
        __Marshaller_mruv_items_GetNearestItemsRequest,
        __Marshaller_mruv_items_GetNearestItemsResponse);

    static readonly grpc::Method<global::Mruv.Items.UseItemRequest, global::Mruv.Items.UseItemResponse> __Method_UseItem = new grpc::Method<global::Mruv.Items.UseItemRequest, global::Mruv.Items.UseItemResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "UseItem",
        __Marshaller_mruv_items_UseItemRequest,
        __Marshaller_mruv_items_UseItemResponse);

    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.Items.ItemsReflection.Descriptor.Services[0]; }
    }

    /// <summary>Base class for server-side implementations of MruVItemService</summary>
    [grpc::BindServiceMethod(typeof(MruVItemService), "BindService")]
    public abstract partial class MruVItemServiceBase
    {
      /// <summary>
      /// Create new item.
      /// </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.Items.ItemID> CreateItem(global::Mruv.Items.Item request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get item by id.
      /// </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.Items.Item> GetItem(global::Mruv.Items.ItemID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete item by id.
      /// </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.Items.ItemID> DeleteItem(global::Mruv.Items.ItemID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Gets all items.
      /// </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.Items.GetItemsResponse> GetItems(global::Mruv.Items.GetItemsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Create item type.
      /// </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.Items.ItemTypeID> CreateItemType(global::Mruv.Items.ItemType request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get item type by id.
      /// </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.Items.ItemType> GetItemType(global::Mruv.Items.ItemTypeID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete item type by id.
      /// </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.Items.ItemTypeID> DeleteItemType(global::Mruv.Items.ItemTypeID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Gets all item types.
      /// </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.Items.GetItemTypesResponse> GetItemTypes(global::Mruv.Items.GetItemTypesRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Create container.
      /// </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.Items.ContainerID> CreateContainer(global::Mruv.Items.Container request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get container by id.
      /// </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.Items.Container> GetContainer(global::Mruv.Items.ContainerID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete container by id.
      /// </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.Items.ContainerID> DeleteContainer(global::Mruv.Items.ContainerID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get all containers.
      /// </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.Items.GetContainersResponse> GetContainers(global::Mruv.Items.GetContainersRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Create a container type.
      /// </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.Items.ContainerTypeID> CreateContainerType(global::Mruv.Items.ContainerType request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get a container type by id.
      /// </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.Items.ContainerType> GetContainerType(global::Mruv.Items.ContainerTypeID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete a container type by id.
      /// </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.Items.ContainerTypeID> DeleteContainerType(global::Mruv.Items.ContainerTypeID request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get all container types.
      /// </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.Items.GetContainerTypesResponse> GetContainerTypes(global::Mruv.Items.GetContainerTypesRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get items inside a container.
      /// </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.Items.GetContainerItemsResponse> GetContainerItems(global::Mruv.Items.GetContainerItemsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Pull an item from container.
      /// </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.Items.Item> PullItem(global::Mruv.Items.PullItemRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Put an item into container.
      /// </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.Items.PutItemResponse> PutItem(global::Mruv.Items.PutItemRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Sort items inside container.
      /// This procedure change order of items inside container.
      /// </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.Items.SortItemsResponse> SortItems(global::Mruv.Items.SortItemsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Retrieves from the container the list of items nearest to the given position.
      /// </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.Items.GetNearestItemsResponse> GetNearestItems(global::Mruv.Items.GetNearestItemsRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Trigger action associated with the item usage.
      /// </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.Items.UseItemResponse> UseItem(global::Mruv.Items.UseItemRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Get service health 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, ""));
      }

      /// <summary>
      ///Get service current version.
      /// </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.VersionResponse> GetServiceVersion(global::Mruv.Common.VersionRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

    }

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

      /// <summary>
      /// Create new item.
      /// </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.Items.ItemID CreateItem(global::Mruv.Items.Item request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateItem(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create new item.
      /// </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.Items.ItemID CreateItem(global::Mruv.Items.Item request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_CreateItem, null, options, request);
      }
      /// <summary>
      /// Create new item.
      /// </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.Items.ItemID> CreateItemAsync(global::Mruv.Items.Item request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateItemAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create new item.
      /// </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.Items.ItemID> CreateItemAsync(global::Mruv.Items.Item request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_CreateItem, null, options, request);
      }
      /// <summary>
      /// Get item by id.
      /// </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.Items.Item GetItem(global::Mruv.Items.ItemID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItem(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get item by id.
      /// </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.Items.Item GetItem(global::Mruv.Items.ItemID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetItem, null, options, request);
      }
      /// <summary>
      /// Get item by id.
      /// </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.Items.Item> GetItemAsync(global::Mruv.Items.ItemID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItemAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get item by id.
      /// </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.Items.Item> GetItemAsync(global::Mruv.Items.ItemID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetItem, null, options, request);
      }
      /// <summary>
      /// Delete item by id.
      /// </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.Items.ItemID DeleteItem(global::Mruv.Items.ItemID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteItem(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete item by id.
      /// </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.Items.ItemID DeleteItem(global::Mruv.Items.ItemID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_DeleteItem, null, options, request);
      }
      /// <summary>
      /// Delete item by id.
      /// </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.Items.ItemID> DeleteItemAsync(global::Mruv.Items.ItemID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteItemAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete item by id.
      /// </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.Items.ItemID> DeleteItemAsync(global::Mruv.Items.ItemID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_DeleteItem, null, options, request);
      }
      /// <summary>
      /// Gets all items.
      /// </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.Items.GetItemsResponse GetItems(global::Mruv.Items.GetItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItems(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Gets all items.
      /// </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.Items.GetItemsResponse GetItems(global::Mruv.Items.GetItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetItems, null, options, request);
      }
      /// <summary>
      /// Gets all items.
      /// </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.Items.GetItemsResponse> GetItemsAsync(global::Mruv.Items.GetItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItemsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Gets all items.
      /// </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.Items.GetItemsResponse> GetItemsAsync(global::Mruv.Items.GetItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetItems, null, options, request);
      }
      /// <summary>
      /// Create item type.
      /// </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.Items.ItemTypeID CreateItemType(global::Mruv.Items.ItemType request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateItemType(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create item type.
      /// </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.Items.ItemTypeID CreateItemType(global::Mruv.Items.ItemType request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_CreateItemType, null, options, request);
      }
      /// <summary>
      /// Create item type.
      /// </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.Items.ItemTypeID> CreateItemTypeAsync(global::Mruv.Items.ItemType request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateItemTypeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create item type.
      /// </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.Items.ItemTypeID> CreateItemTypeAsync(global::Mruv.Items.ItemType request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_CreateItemType, null, options, request);
      }
      /// <summary>
      /// Get item type by id.
      /// </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.Items.ItemType GetItemType(global::Mruv.Items.ItemTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItemType(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get item type by id.
      /// </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.Items.ItemType GetItemType(global::Mruv.Items.ItemTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetItemType, null, options, request);
      }
      /// <summary>
      /// Get item type by id.
      /// </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.Items.ItemType> GetItemTypeAsync(global::Mruv.Items.ItemTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItemTypeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get item type by id.
      /// </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.Items.ItemType> GetItemTypeAsync(global::Mruv.Items.ItemTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetItemType, null, options, request);
      }
      /// <summary>
      /// Delete item type by id.
      /// </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.Items.ItemTypeID DeleteItemType(global::Mruv.Items.ItemTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteItemType(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete item type by id.
      /// </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.Items.ItemTypeID DeleteItemType(global::Mruv.Items.ItemTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_DeleteItemType, null, options, request);
      }
      /// <summary>
      /// Delete item type by id.
      /// </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.Items.ItemTypeID> DeleteItemTypeAsync(global::Mruv.Items.ItemTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteItemTypeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete item type by id.
      /// </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.Items.ItemTypeID> DeleteItemTypeAsync(global::Mruv.Items.ItemTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_DeleteItemType, null, options, request);
      }
      /// <summary>
      /// Gets all item types.
      /// </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.Items.GetItemTypesResponse GetItemTypes(global::Mruv.Items.GetItemTypesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItemTypes(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Gets all item types.
      /// </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.Items.GetItemTypesResponse GetItemTypes(global::Mruv.Items.GetItemTypesRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetItemTypes, null, options, request);
      }
      /// <summary>
      /// Gets all item types.
      /// </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.Items.GetItemTypesResponse> GetItemTypesAsync(global::Mruv.Items.GetItemTypesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetItemTypesAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Gets all item types.
      /// </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.Items.GetItemTypesResponse> GetItemTypesAsync(global::Mruv.Items.GetItemTypesRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetItemTypes, null, options, request);
      }
      /// <summary>
      /// Create container.
      /// </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.Items.ContainerID CreateContainer(global::Mruv.Items.Container request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateContainer(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create container.
      /// </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.Items.ContainerID CreateContainer(global::Mruv.Items.Container request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_CreateContainer, null, options, request);
      }
      /// <summary>
      /// Create container.
      /// </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.Items.ContainerID> CreateContainerAsync(global::Mruv.Items.Container request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateContainerAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create container.
      /// </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.Items.ContainerID> CreateContainerAsync(global::Mruv.Items.Container request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_CreateContainer, null, options, request);
      }
      /// <summary>
      /// Get container by id.
      /// </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.Items.Container GetContainer(global::Mruv.Items.ContainerID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainer(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get container by id.
      /// </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.Items.Container GetContainer(global::Mruv.Items.ContainerID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetContainer, null, options, request);
      }
      /// <summary>
      /// Get container by id.
      /// </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.Items.Container> GetContainerAsync(global::Mruv.Items.ContainerID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get container by id.
      /// </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.Items.Container> GetContainerAsync(global::Mruv.Items.ContainerID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetContainer, null, options, request);
      }
      /// <summary>
      /// Delete container by id.
      /// </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.Items.ContainerID DeleteContainer(global::Mruv.Items.ContainerID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteContainer(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete container by id.
      /// </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.Items.ContainerID DeleteContainer(global::Mruv.Items.ContainerID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_DeleteContainer, null, options, request);
      }
      /// <summary>
      /// Delete container by id.
      /// </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.Items.ContainerID> DeleteContainerAsync(global::Mruv.Items.ContainerID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteContainerAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete container by id.
      /// </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.Items.ContainerID> DeleteContainerAsync(global::Mruv.Items.ContainerID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_DeleteContainer, null, options, request);
      }
      /// <summary>
      /// Get all containers.
      /// </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.Items.GetContainersResponse GetContainers(global::Mruv.Items.GetContainersRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainers(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all containers.
      /// </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.Items.GetContainersResponse GetContainers(global::Mruv.Items.GetContainersRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetContainers, null, options, request);
      }
      /// <summary>
      /// Get all containers.
      /// </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.Items.GetContainersResponse> GetContainersAsync(global::Mruv.Items.GetContainersRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainersAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all containers.
      /// </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.Items.GetContainersResponse> GetContainersAsync(global::Mruv.Items.GetContainersRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetContainers, null, options, request);
      }
      /// <summary>
      /// Create a container type.
      /// </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.Items.ContainerTypeID CreateContainerType(global::Mruv.Items.ContainerType request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateContainerType(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create a container type.
      /// </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.Items.ContainerTypeID CreateContainerType(global::Mruv.Items.ContainerType request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_CreateContainerType, null, options, request);
      }
      /// <summary>
      /// Create a container type.
      /// </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.Items.ContainerTypeID> CreateContainerTypeAsync(global::Mruv.Items.ContainerType request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return CreateContainerTypeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create a container type.
      /// </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.Items.ContainerTypeID> CreateContainerTypeAsync(global::Mruv.Items.ContainerType request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_CreateContainerType, null, options, request);
      }
      /// <summary>
      /// Get a container type by id.
      /// </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.Items.ContainerType GetContainerType(global::Mruv.Items.ContainerTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerType(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a container type by id.
      /// </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.Items.ContainerType GetContainerType(global::Mruv.Items.ContainerTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetContainerType, null, options, request);
      }
      /// <summary>
      /// Get a container type by id.
      /// </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.Items.ContainerType> GetContainerTypeAsync(global::Mruv.Items.ContainerTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerTypeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get a container type by id.
      /// </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.Items.ContainerType> GetContainerTypeAsync(global::Mruv.Items.ContainerTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetContainerType, null, options, request);
      }
      /// <summary>
      /// Delete a container type by id.
      /// </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.Items.ContainerTypeID DeleteContainerType(global::Mruv.Items.ContainerTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteContainerType(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete a container type by id.
      /// </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.Items.ContainerTypeID DeleteContainerType(global::Mruv.Items.ContainerTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_DeleteContainerType, null, options, request);
      }
      /// <summary>
      /// Delete a container type by id.
      /// </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.Items.ContainerTypeID> DeleteContainerTypeAsync(global::Mruv.Items.ContainerTypeID request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return DeleteContainerTypeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete a container type by id.
      /// </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.Items.ContainerTypeID> DeleteContainerTypeAsync(global::Mruv.Items.ContainerTypeID request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_DeleteContainerType, null, options, request);
      }
      /// <summary>
      /// Get all container types.
      /// </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.Items.GetContainerTypesResponse GetContainerTypes(global::Mruv.Items.GetContainerTypesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerTypes(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all container types.
      /// </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.Items.GetContainerTypesResponse GetContainerTypes(global::Mruv.Items.GetContainerTypesRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetContainerTypes, null, options, request);
      }
      /// <summary>
      /// Get all container types.
      /// </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.Items.GetContainerTypesResponse> GetContainerTypesAsync(global::Mruv.Items.GetContainerTypesRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerTypesAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get all container types.
      /// </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.Items.GetContainerTypesResponse> GetContainerTypesAsync(global::Mruv.Items.GetContainerTypesRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetContainerTypes, null, options, request);
      }
      /// <summary>
      /// Get items inside a container.
      /// </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.Items.GetContainerItemsResponse GetContainerItems(global::Mruv.Items.GetContainerItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerItems(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get items inside a container.
      /// </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.Items.GetContainerItemsResponse GetContainerItems(global::Mruv.Items.GetContainerItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetContainerItems, null, options, request);
      }
      /// <summary>
      /// Get items inside a container.
      /// </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.Items.GetContainerItemsResponse> GetContainerItemsAsync(global::Mruv.Items.GetContainerItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetContainerItemsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Get items inside a container.
      /// </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.Items.GetContainerItemsResponse> GetContainerItemsAsync(global::Mruv.Items.GetContainerItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetContainerItems, null, options, request);
      }
      /// <summary>
      /// Pull an item from container.
      /// </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.Items.Item PullItem(global::Mruv.Items.PullItemRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return PullItem(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Pull an item from container.
      /// </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.Items.Item PullItem(global::Mruv.Items.PullItemRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_PullItem, null, options, request);
      }
      /// <summary>
      /// Pull an item from container.
      /// </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.Items.Item> PullItemAsync(global::Mruv.Items.PullItemRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return PullItemAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Pull an item from container.
      /// </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.Items.Item> PullItemAsync(global::Mruv.Items.PullItemRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_PullItem, null, options, request);
      }
      /// <summary>
      /// Put an item into container.
      /// </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.Items.PutItemResponse PutItem(global::Mruv.Items.PutItemRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return PutItem(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Put an item into container.
      /// </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.Items.PutItemResponse PutItem(global::Mruv.Items.PutItemRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_PutItem, null, options, request);
      }
      /// <summary>
      /// Put an item into container.
      /// </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.Items.PutItemResponse> PutItemAsync(global::Mruv.Items.PutItemRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return PutItemAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Put an item into container.
      /// </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.Items.PutItemResponse> PutItemAsync(global::Mruv.Items.PutItemRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_PutItem, null, options, request);
      }
      /// <summary>
      /// Sort items inside container.
      /// This procedure change order of items inside container.
      /// </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.Items.SortItemsResponse SortItems(global::Mruv.Items.SortItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return SortItems(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Sort items inside container.
      /// This procedure change order of items inside container.
      /// </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.Items.SortItemsResponse SortItems(global::Mruv.Items.SortItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_SortItems, null, options, request);
      }
      /// <summary>
      /// Sort items inside container.
      /// This procedure change order of items inside container.
      /// </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.Items.SortItemsResponse> SortItemsAsync(global::Mruv.Items.SortItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return SortItemsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Sort items inside container.
      /// This procedure change order of items inside container.
      /// </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.Items.SortItemsResponse> SortItemsAsync(global::Mruv.Items.SortItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_SortItems, null, options, request);
      }
      /// <summary>
      /// Retrieves from the container the list of items nearest to the given position.
      /// </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.Items.GetNearestItemsResponse GetNearestItems(global::Mruv.Items.GetNearestItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetNearestItems(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Retrieves from the container the list of items nearest to the given position.
      /// </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.Items.GetNearestItemsResponse GetNearestItems(global::Mruv.Items.GetNearestItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetNearestItems, null, options, request);
      }
      /// <summary>
      /// Retrieves from the container the list of items nearest to the given position.
      /// </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.Items.GetNearestItemsResponse> GetNearestItemsAsync(global::Mruv.Items.GetNearestItemsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return GetNearestItemsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Retrieves from the container the list of items nearest to the given position.
      /// </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.Items.GetNearestItemsResponse> GetNearestItemsAsync(global::Mruv.Items.GetNearestItemsRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetNearestItems, null, options, request);
      }
      /// <summary>
      /// Trigger action associated with the item usage.
      /// </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.Items.UseItemResponse UseItem(global::Mruv.Items.UseItemRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UseItem(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Trigger action associated with the item usage.
      /// </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.Items.UseItemResponse UseItem(global::Mruv.Items.UseItemRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_UseItem, null, options, request);
      }
      /// <summary>
      /// Trigger action associated with the item usage.
      /// </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.Items.UseItemResponse> UseItemAsync(global::Mruv.Items.UseItemRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken))
      {
        return UseItemAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Trigger action associated with the item usage.
      /// </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.Items.UseItemResponse> UseItemAsync(global::Mruv.Items.UseItemRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_UseItem, null, options, request);
      }
      /// <summary>
      /// Get service health 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>
      /// Get service health 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>
      /// Get service health 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>
      /// Get service health 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);
      }
      /// <summary>
      ///Get service current version.
      /// </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.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));
      }
      /// <summary>
      ///Get service current version.
      /// </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.VersionResponse GetServiceVersion(global::Mruv.Common.VersionRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetServiceVersion, null, options, request);
      }
      /// <summary>
      ///Get service current version.
      /// </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.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));
      }
      /// <summary>
      ///Get service current version.
      /// </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.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 MruVItemServiceClient NewInstance(ClientBaseConfiguration configuration)
      {
        return new MruVItemServiceClient(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(MruVItemServiceBase serviceImpl)
    {
      return grpc::ServerServiceDefinition.CreateBuilder()
          .AddMethod(__Method_CreateItem, serviceImpl.CreateItem)
          .AddMethod(__Method_GetItem, serviceImpl.GetItem)
          .AddMethod(__Method_DeleteItem, serviceImpl.DeleteItem)
          .AddMethod(__Method_GetItems, serviceImpl.GetItems)
          .AddMethod(__Method_CreateItemType, serviceImpl.CreateItemType)
          .AddMethod(__Method_GetItemType, serviceImpl.GetItemType)
          .AddMethod(__Method_DeleteItemType, serviceImpl.DeleteItemType)
          .AddMethod(__Method_GetItemTypes, serviceImpl.GetItemTypes)
          .AddMethod(__Method_CreateContainer, serviceImpl.CreateContainer)
          .AddMethod(__Method_GetContainer, serviceImpl.GetContainer)
          .AddMethod(__Method_DeleteContainer, serviceImpl.DeleteContainer)
          .AddMethod(__Method_GetContainers, serviceImpl.GetContainers)
          .AddMethod(__Method_CreateContainerType, serviceImpl.CreateContainerType)
          .AddMethod(__Method_GetContainerType, serviceImpl.GetContainerType)
          .AddMethod(__Method_DeleteContainerType, serviceImpl.DeleteContainerType)
          .AddMethod(__Method_GetContainerTypes, serviceImpl.GetContainerTypes)
          .AddMethod(__Method_GetContainerItems, serviceImpl.GetContainerItems)
          .AddMethod(__Method_PullItem, serviceImpl.PullItem)
          .AddMethod(__Method_PutItem, serviceImpl.PutItem)
          .AddMethod(__Method_SortItems, serviceImpl.SortItems)
          .AddMethod(__Method_GetNearestItems, serviceImpl.GetNearestItems)
          .AddMethod(__Method_UseItem, serviceImpl.UseItem)
          .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, MruVItemServiceBase serviceImpl)
    {
      serviceBinder.AddMethod(__Method_CreateItem, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.Item, global::Mruv.Items.ItemID>(serviceImpl.CreateItem));
      serviceBinder.AddMethod(__Method_GetItem, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ItemID, global::Mruv.Items.Item>(serviceImpl.GetItem));
      serviceBinder.AddMethod(__Method_DeleteItem, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ItemID, global::Mruv.Items.ItemID>(serviceImpl.DeleteItem));
      serviceBinder.AddMethod(__Method_GetItems, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.GetItemsRequest, global::Mruv.Items.GetItemsResponse>(serviceImpl.GetItems));
      serviceBinder.AddMethod(__Method_CreateItemType, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ItemType, global::Mruv.Items.ItemTypeID>(serviceImpl.CreateItemType));
      serviceBinder.AddMethod(__Method_GetItemType, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ItemTypeID, global::Mruv.Items.ItemType>(serviceImpl.GetItemType));
      serviceBinder.AddMethod(__Method_DeleteItemType, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ItemTypeID, global::Mruv.Items.ItemTypeID>(serviceImpl.DeleteItemType));
      serviceBinder.AddMethod(__Method_GetItemTypes, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.GetItemTypesRequest, global::Mruv.Items.GetItemTypesResponse>(serviceImpl.GetItemTypes));
      serviceBinder.AddMethod(__Method_CreateContainer, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.Container, global::Mruv.Items.ContainerID>(serviceImpl.CreateContainer));
      serviceBinder.AddMethod(__Method_GetContainer, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ContainerID, global::Mruv.Items.Container>(serviceImpl.GetContainer));
      serviceBinder.AddMethod(__Method_DeleteContainer, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ContainerID, global::Mruv.Items.ContainerID>(serviceImpl.DeleteContainer));
      serviceBinder.AddMethod(__Method_GetContainers, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.GetContainersRequest, global::Mruv.Items.GetContainersResponse>(serviceImpl.GetContainers));
      serviceBinder.AddMethod(__Method_CreateContainerType, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ContainerType, global::Mruv.Items.ContainerTypeID>(serviceImpl.CreateContainerType));
      serviceBinder.AddMethod(__Method_GetContainerType, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ContainerTypeID, global::Mruv.Items.ContainerType>(serviceImpl.GetContainerType));
      serviceBinder.AddMethod(__Method_DeleteContainerType, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.ContainerTypeID, global::Mruv.Items.ContainerTypeID>(serviceImpl.DeleteContainerType));
      serviceBinder.AddMethod(__Method_GetContainerTypes, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.GetContainerTypesRequest, global::Mruv.Items.GetContainerTypesResponse>(serviceImpl.GetContainerTypes));
      serviceBinder.AddMethod(__Method_GetContainerItems, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.GetContainerItemsRequest, global::Mruv.Items.GetContainerItemsResponse>(serviceImpl.GetContainerItems));
      serviceBinder.AddMethod(__Method_PullItem, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.PullItemRequest, global::Mruv.Items.Item>(serviceImpl.PullItem));
      serviceBinder.AddMethod(__Method_PutItem, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.PutItemRequest, global::Mruv.Items.PutItemResponse>(serviceImpl.PutItem));
      serviceBinder.AddMethod(__Method_SortItems, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.SortItemsRequest, global::Mruv.Items.SortItemsResponse>(serviceImpl.SortItems));
      serviceBinder.AddMethod(__Method_GetNearestItems, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.GetNearestItemsRequest, global::Mruv.Items.GetNearestItemsResponse>(serviceImpl.GetNearestItems));
      serviceBinder.AddMethod(__Method_UseItem, serviceImpl == null ? null : new grpc::UnaryServerMethod<global::Mruv.Items.UseItemRequest, global::Mruv.Items.UseItemResponse>(serviceImpl.UseItem));
      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