rocketmq-client-nodejs/proto/apache/rocketmq/v2/service_grpc_pb.js

RocketMQ Node.js Client

// GENERATED CODE -- DO NOT EDIT!

// Original file comments:
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
'use strict';
var grpc = require('@grpc/grpc-js');
var apache_rocketmq_v2_service_pb = require('../../../apache/rocketmq/v2/service_pb.js');
var google_protobuf_duration_pb = require('google-protobuf/google/protobuf/duration_pb.js');
var google_protobuf_timestamp_pb = require('google-protobuf/google/protobuf/timestamp_pb.js');
var apache_rocketmq_v2_definition_pb = require('../../../apache/rocketmq/v2/definition_pb.js');

function serialize_apache_rocketmq_v2_AckMessageRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.AckMessageRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.AckMessageRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_AckMessageRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.AckMessageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_AckMessageResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.AckMessageResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.AckMessageResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_AckMessageResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.AckMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_ChangeInvisibleDurationRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.ChangeInvisibleDurationRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.ChangeInvisibleDurationRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_ChangeInvisibleDurationRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.ChangeInvisibleDurationRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_ChangeInvisibleDurationResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.ChangeInvisibleDurationResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.ChangeInvisibleDurationResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_ChangeInvisibleDurationResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.ChangeInvisibleDurationResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_EndTransactionRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.EndTransactionRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.EndTransactionRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_EndTransactionRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.EndTransactionRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_EndTransactionResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.EndTransactionResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.EndTransactionResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_EndTransactionResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.EndTransactionResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.ForwardMessageToDeadLetterQueueRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.ForwardMessageToDeadLetterQueueRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.ForwardMessageToDeadLetterQueueRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.ForwardMessageToDeadLetterQueueResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.ForwardMessageToDeadLetterQueueResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.ForwardMessageToDeadLetterQueueResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_GetOffsetRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.GetOffsetRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.GetOffsetRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_GetOffsetRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.GetOffsetRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_GetOffsetResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.GetOffsetResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.GetOffsetResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_GetOffsetResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.GetOffsetResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_HeartbeatRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.HeartbeatRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.HeartbeatRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_HeartbeatRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.HeartbeatRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_HeartbeatResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.HeartbeatResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.HeartbeatResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_HeartbeatResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.HeartbeatResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_NotifyClientTerminationRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.NotifyClientTerminationRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.NotifyClientTerminationRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_NotifyClientTerminationRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.NotifyClientTerminationRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_NotifyClientTerminationResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.NotifyClientTerminationResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.NotifyClientTerminationResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_NotifyClientTerminationResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.NotifyClientTerminationResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_PullMessageRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.PullMessageRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.PullMessageRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_PullMessageRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.PullMessageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_PullMessageResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.PullMessageResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.PullMessageResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_PullMessageResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.PullMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_QueryAssignmentRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.QueryAssignmentRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.QueryAssignmentRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_QueryAssignmentRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.QueryAssignmentRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_QueryAssignmentResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.QueryAssignmentResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.QueryAssignmentResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_QueryAssignmentResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.QueryAssignmentResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_QueryOffsetRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.QueryOffsetRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.QueryOffsetRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_QueryOffsetRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.QueryOffsetRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_QueryOffsetResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.QueryOffsetResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.QueryOffsetResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_QueryOffsetResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.QueryOffsetResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_QueryRouteRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.QueryRouteRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.QueryRouteRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_QueryRouteRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.QueryRouteRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_QueryRouteResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.QueryRouteResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.QueryRouteResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_QueryRouteResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.QueryRouteResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_RecallMessageRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.RecallMessageRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.RecallMessageRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_RecallMessageRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.RecallMessageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_RecallMessageResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.RecallMessageResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.RecallMessageResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_RecallMessageResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.RecallMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_ReceiveMessageRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.ReceiveMessageRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.ReceiveMessageRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_ReceiveMessageRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.ReceiveMessageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_ReceiveMessageResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.ReceiveMessageResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.ReceiveMessageResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_ReceiveMessageResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.ReceiveMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_SendMessageRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.SendMessageRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.SendMessageRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_SendMessageRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.SendMessageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_SendMessageResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.SendMessageResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.SendMessageResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_SendMessageResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.SendMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_SyncLiteSubscriptionRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.SyncLiteSubscriptionRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.SyncLiteSubscriptionRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_SyncLiteSubscriptionRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.SyncLiteSubscriptionRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_SyncLiteSubscriptionResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.SyncLiteSubscriptionResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.SyncLiteSubscriptionResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_SyncLiteSubscriptionResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.SyncLiteSubscriptionResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_TelemetryCommand(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.TelemetryCommand)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.TelemetryCommand');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_TelemetryCommand(buffer_arg) {
  return apache_rocketmq_v2_service_pb.TelemetryCommand.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_UpdateOffsetRequest(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.UpdateOffsetRequest)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.UpdateOffsetRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_UpdateOffsetRequest(buffer_arg) {
  return apache_rocketmq_v2_service_pb.UpdateOffsetRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_apache_rocketmq_v2_UpdateOffsetResponse(arg) {
  if (!(arg instanceof apache_rocketmq_v2_service_pb.UpdateOffsetResponse)) {
    throw new Error('Expected argument of type apache.rocketmq.v2.UpdateOffsetResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_apache_rocketmq_v2_UpdateOffsetResponse(buffer_arg) {
  return apache_rocketmq_v2_service_pb.UpdateOffsetResponse.deserializeBinary(new Uint8Array(buffer_arg));
}


// For all the RPCs in MessagingService, the following error handling policies
// apply:
//
// If the request doesn't bear a valid authentication credential, return a
// response with common.status.code == `UNAUTHENTICATED`. If the authenticated
// user is not granted with sufficient permission to execute the requested
// operation, return a response with common.status.code == `PERMISSION_DENIED`.
// If the per-user-resource-based quota is exhausted, return a response with
// common.status.code == `RESOURCE_EXHAUSTED`. If any unexpected server-side
// errors raise, return a response with common.status.code == `INTERNAL`.
var MessagingServiceService = exports.MessagingServiceService = {
  // Queries the route entries of the requested topic in the perspective of the
// given endpoints. On success, servers should return a collection of
// addressable message-queues. Note servers may return customized route
// entries based on endpoints provided.
//
// If the requested topic doesn't exist, returns `NOT_FOUND`.
// If the specific endpoints is empty, returns `INVALID_ARGUMENT`.
queryRoute: {
    path: '/apache.rocketmq.v2.MessagingService/QueryRoute',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.QueryRouteRequest,
    responseType: apache_rocketmq_v2_service_pb.QueryRouteResponse,
    requestSerialize: serialize_apache_rocketmq_v2_QueryRouteRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_QueryRouteRequest,
    responseSerialize: serialize_apache_rocketmq_v2_QueryRouteResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_QueryRouteResponse,
  },
  // Producer or consumer sends HeartbeatRequest to servers periodically to
// keep-alive. Additionally, it also reports client-side configuration,
// including topic subscription, load-balancing group name, etc.
//
// Returns `OK` if success.
//
// If a client specifies a language that is not yet supported by servers,
// returns `INVALID_ARGUMENT`
heartbeat: {
    path: '/apache.rocketmq.v2.MessagingService/Heartbeat',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.HeartbeatRequest,
    responseType: apache_rocketmq_v2_service_pb.HeartbeatResponse,
    requestSerialize: serialize_apache_rocketmq_v2_HeartbeatRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_HeartbeatRequest,
    responseSerialize: serialize_apache_rocketmq_v2_HeartbeatResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_HeartbeatResponse,
  },
  // Delivers messages to brokers.
// Clients may further:
// 1. Refine a message destination to message-queues which fulfills parts of
// FIFO semantic;
// 2. Flag a message as transactional, which keeps it invisible to consumers
// until it commits;
// 3. Time a message, making it invisible to consumers till specified
// time-point;
// 4. And more...
//
// Returns message-id or transaction-id with status `OK` on success.
//
// If the destination topic doesn't exist, returns `NOT_FOUND`.
sendMessage: {
    path: '/apache.rocketmq.v2.MessagingService/SendMessage',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.SendMessageRequest,
    responseType: apache_rocketmq_v2_service_pb.SendMessageResponse,
    requestSerialize: serialize_apache_rocketmq_v2_SendMessageRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_SendMessageRequest,
    responseSerialize: serialize_apache_rocketmq_v2_SendMessageResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_SendMessageResponse,
  },
  // Queries the assigned route info of a topic for current consumer,
// the returned assignment result is decided by server-side load balancer.
//
// If the corresponding topic doesn't exist, returns `NOT_FOUND`.
// If the specific endpoints is empty, returns `INVALID_ARGUMENT`.
queryAssignment: {
    path: '/apache.rocketmq.v2.MessagingService/QueryAssignment',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.QueryAssignmentRequest,
    responseType: apache_rocketmq_v2_service_pb.QueryAssignmentResponse,
    requestSerialize: serialize_apache_rocketmq_v2_QueryAssignmentRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_QueryAssignmentRequest,
    responseSerialize: serialize_apache_rocketmq_v2_QueryAssignmentResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_QueryAssignmentResponse,
  },
  // Receives messages from the server in batch manner, returns a set of
// messages if success. The received messages should be acked or redelivered
// after processed.
//
// If the pending concurrent receive requests exceed the quota of the given
// consumer group, returns `UNAVAILABLE`. If the upstream store server hangs,
// return `DEADLINE_EXCEEDED` in a timely manner. If the corresponding topic
// or consumer group doesn't exist, returns `NOT_FOUND`. If there is no new
// message in the specific topic, returns `OK` with an empty message set.
// Please note that client may suffer from false empty responses.
//
// If failed to receive message from remote, server must return only one
// `ReceiveMessageResponse` as the reply to the request, whose `Status` indicates
// the specific reason of failure, otherwise, the reply is considered successful.
receiveMessage: {
    path: '/apache.rocketmq.v2.MessagingService/ReceiveMessage',
    requestStream: false,
    responseStream: true,
    requestType: apache_rocketmq_v2_service_pb.ReceiveMessageRequest,
    responseType: apache_rocketmq_v2_service_pb.ReceiveMessageResponse,
    requestSerialize: serialize_apache_rocketmq_v2_ReceiveMessageRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_ReceiveMessageRequest,
    responseSerialize: serialize_apache_rocketmq_v2_ReceiveMessageResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_ReceiveMessageResponse,
  },
  // Acknowledges the message associated with the `receipt_handle` or `offset`
// in the `AckMessageRequest`, it means the message has been successfully
// processed. Returns `OK` if the message server remove the relevant message
// successfully.
//
// If the given receipt_handle is illegal or out of date, returns
// `INVALID_ARGUMENT`.
ackMessage: {
    path: '/apache.rocketmq.v2.MessagingService/AckMessage',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.AckMessageRequest,
    responseType: apache_rocketmq_v2_service_pb.AckMessageResponse,
    requestSerialize: serialize_apache_rocketmq_v2_AckMessageRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_AckMessageRequest,
    responseSerialize: serialize_apache_rocketmq_v2_AckMessageResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_AckMessageResponse,
  },
  // Forwards one message to dead letter queue if the max delivery attempts is
// exceeded by this message at client-side, return `OK` if success.
forwardMessageToDeadLetterQueue: {
    path: '/apache.rocketmq.v2.MessagingService/ForwardMessageToDeadLetterQueue',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.ForwardMessageToDeadLetterQueueRequest,
    responseType: apache_rocketmq_v2_service_pb.ForwardMessageToDeadLetterQueueResponse,
    requestSerialize: serialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueRequest,
    responseSerialize: serialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_ForwardMessageToDeadLetterQueueResponse,
  },
  // PullMessage and ReceiveMessage RPCs serve a similar purpose,
// which is to attempt to get messages from the server, but with different semantics.
pullMessage: {
    path: '/apache.rocketmq.v2.MessagingService/PullMessage',
    requestStream: false,
    responseStream: true,
    requestType: apache_rocketmq_v2_service_pb.PullMessageRequest,
    responseType: apache_rocketmq_v2_service_pb.PullMessageResponse,
    requestSerialize: serialize_apache_rocketmq_v2_PullMessageRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_PullMessageRequest,
    responseSerialize: serialize_apache_rocketmq_v2_PullMessageResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_PullMessageResponse,
  },
  // Update the consumption progress of the designated queue of the
// consumer group to the remote.
updateOffset: {
    path: '/apache.rocketmq.v2.MessagingService/UpdateOffset',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.UpdateOffsetRequest,
    responseType: apache_rocketmq_v2_service_pb.UpdateOffsetResponse,
    requestSerialize: serialize_apache_rocketmq_v2_UpdateOffsetRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_UpdateOffsetRequest,
    responseSerialize: serialize_apache_rocketmq_v2_UpdateOffsetResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_UpdateOffsetResponse,
  },
  // Query the consumption progress of the designated queue of the
// consumer group to the remote.
getOffset: {
    path: '/apache.rocketmq.v2.MessagingService/GetOffset',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.GetOffsetRequest,
    responseType: apache_rocketmq_v2_service_pb.GetOffsetResponse,
    requestSerialize: serialize_apache_rocketmq_v2_GetOffsetRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_GetOffsetRequest,
    responseSerialize: serialize_apache_rocketmq_v2_GetOffsetResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_GetOffsetResponse,
  },
  // Query the offset of the designated queue by the query offset policy.
queryOffset: {
    path: '/apache.rocketmq.v2.MessagingService/QueryOffset',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.QueryOffsetRequest,
    responseType: apache_rocketmq_v2_service_pb.QueryOffsetResponse,
    requestSerialize: serialize_apache_rocketmq_v2_QueryOffsetRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_QueryOffsetRequest,
    responseSerialize: serialize_apache_rocketmq_v2_QueryOffsetResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_QueryOffsetResponse,
  },
  // Commits or rollback one transactional message.
endTransaction: {
    path: '/apache.rocketmq.v2.MessagingService/EndTransaction',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.EndTransactionRequest,
    responseType: apache_rocketmq_v2_service_pb.EndTransactionResponse,
    requestSerialize: serialize_apache_rocketmq_v2_EndTransactionRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_EndTransactionRequest,
    responseSerialize: serialize_apache_rocketmq_v2_EndTransactionResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_EndTransactionResponse,
  },
  // Once a client starts, it would immediately establishes bi-lateral stream
// RPCs with brokers, reporting its settings as the initiative command.
//
// When servers have need of inspecting client status, they would issue
// telemetry commands to clients. After executing received instructions,
// clients shall report command execution results through client-side streams.
telemetry: {
    path: '/apache.rocketmq.v2.MessagingService/Telemetry',
    requestStream: true,
    responseStream: true,
    requestType: apache_rocketmq_v2_service_pb.TelemetryCommand,
    responseType: apache_rocketmq_v2_service_pb.TelemetryCommand,
    requestSerialize: serialize_apache_rocketmq_v2_TelemetryCommand,
    requestDeserialize: deserialize_apache_rocketmq_v2_TelemetryCommand,
    responseSerialize: serialize_apache_rocketmq_v2_TelemetryCommand,
    responseDeserialize: deserialize_apache_rocketmq_v2_TelemetryCommand,
  },
  // Notify the server that the client is terminated.
notifyClientTermination: {
    path: '/apache.rocketmq.v2.MessagingService/NotifyClientTermination',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.NotifyClientTerminationRequest,
    responseType: apache_rocketmq_v2_service_pb.NotifyClientTerminationResponse,
    requestSerialize: serialize_apache_rocketmq_v2_NotifyClientTerminationRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_NotifyClientTerminationRequest,
    responseSerialize: serialize_apache_rocketmq_v2_NotifyClientTerminationResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_NotifyClientTerminationResponse,
  },
  // Once a message is retrieved from consume queue on behalf of the group, it
// will be kept invisible to other clients of the same group for a period of
// time. The message is supposed to be processed within the invisible
// duration. If the client, which is in charge of the invisible message, is
// not capable of processing the message timely, it may use
// ChangeInvisibleDuration to lengthen invisible duration.
changeInvisibleDuration: {
    path: '/apache.rocketmq.v2.MessagingService/ChangeInvisibleDuration',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.ChangeInvisibleDurationRequest,
    responseType: apache_rocketmq_v2_service_pb.ChangeInvisibleDurationResponse,
    requestSerialize: serialize_apache_rocketmq_v2_ChangeInvisibleDurationRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_ChangeInvisibleDurationRequest,
    responseSerialize: serialize_apache_rocketmq_v2_ChangeInvisibleDurationResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_ChangeInvisibleDurationResponse,
  },
  // Recall a message,
// for delay message, should recall before delivery time, like the rollback operation of transaction message,
// for normal message, not supported for now.
recallMessage: {
    path: '/apache.rocketmq.v2.MessagingService/RecallMessage',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.RecallMessageRequest,
    responseType: apache_rocketmq_v2_service_pb.RecallMessageResponse,
    requestSerialize: serialize_apache_rocketmq_v2_RecallMessageRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_RecallMessageRequest,
    responseSerialize: serialize_apache_rocketmq_v2_RecallMessageResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_RecallMessageResponse,
  },
  // Sync lite subscription info, lite push consumer only
syncLiteSubscription: {
    path: '/apache.rocketmq.v2.MessagingService/SyncLiteSubscription',
    requestStream: false,
    responseStream: false,
    requestType: apache_rocketmq_v2_service_pb.SyncLiteSubscriptionRequest,
    responseType: apache_rocketmq_v2_service_pb.SyncLiteSubscriptionResponse,
    requestSerialize: serialize_apache_rocketmq_v2_SyncLiteSubscriptionRequest,
    requestDeserialize: deserialize_apache_rocketmq_v2_SyncLiteSubscriptionRequest,
    responseSerialize: serialize_apache_rocketmq_v2_SyncLiteSubscriptionResponse,
    responseDeserialize: deserialize_apache_rocketmq_v2_SyncLiteSubscriptionResponse,
  },
};

exports.MessagingServiceClient = grpc.makeGenericClientConstructor(MessagingServiceService, 'MessagingService');