public virtual global::System.Threading.Tasks.Task MoveMouse(grpc::IAsyncStreamReader <global::Service.MouseCoords> requestStream, grpc::IServerStreamWriter <global::Service.Response> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Put the object into container. Request uses gRPC stream. First message
/// SHOULD be of PutHeader type. `ContainerID` and `OwnerID` of an object
/// SHOULD be set. Session token SHOULD be obtained before `PUT` operation (see
/// session package). Chunk messages are considered by server as a part of an
/// object payload. All messages, except first one, SHOULD be payload chunks.
/// Chunk messages SHOULD be sent in direct order of fragmentation.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>The response to send back to the client (wrapped by a task).</returns>
public virtual global::System.Threading.Tasks.Task <global::NeoFS.API.v2.Object.PutResponse> Put(grpc::IAsyncStreamReader <global::NeoFS.API.v2.Object.PutRequest> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// A Bidirectional streaming RPC.
///
/// Accepts a stream of RouteNotes sent while a route is being traversed,
/// while receiving other RouteNotes (e.g. from other users).
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task RouteChat(grpc::IAsyncStreamReader <global::Routeguide.RouteNote> requestStream, grpc::IServerStreamWriter <global::Routeguide.RouteNote> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task SendEventsStream(grpc::IAsyncStreamReader <global::KubeMQ.Grpc.Event> requestStream, grpc::IServerStreamWriter <global::KubeMQ.Grpc.Result> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Initiates or continues a conversation with the embedded Assistant Service.
/// Each call performs one round-trip, sending an audio request to the service
/// and receiving the audio response. Uses bidirectional streaming to receive
/// results, such as the `END_OF_UTTERANCE` event, while sending audio.
///
/// A conversation is one or more gRPC connections, each consisting of several
/// streamed requests and responses.
/// For example, the user says *Add to my shopping list* and the Assistant
/// responds *What do you want to add?*. The sequence of streamed requests and
/// responses in the first gRPC message could be:
///
/// * AssistRequest.config
/// * AssistRequest.audio_in
/// * AssistRequest.audio_in
/// * AssistRequest.audio_in
/// * AssistRequest.audio_in
/// * AssistResponse.event_type.END_OF_UTTERANCE
/// * AssistResponse.speech_results.transcript "add to my shopping list"
/// * AssistResponse.dialog_state_out.microphone_mode.DIALOG_FOLLOW_ON
/// * AssistResponse.audio_out
/// * AssistResponse.audio_out
/// * AssistResponse.audio_out
///
/// The user then says *bagels* and the Assistant responds
/// *OK, I've added bagels to your shopping list*. This is sent as another gRPC
/// connection call to the `Assist` method, again with streamed requests and
/// responses, such as:
///
/// * AssistRequest.config
/// * AssistRequest.audio_in
/// * AssistRequest.audio_in
/// * AssistRequest.audio_in
/// * AssistResponse.event_type.END_OF_UTTERANCE
/// * AssistResponse.dialog_state_out.microphone_mode.CLOSE_MICROPHONE
/// * AssistResponse.audio_out
/// * AssistResponse.audio_out
/// * AssistResponse.audio_out
/// * AssistResponse.audio_out
///
/// Although the precise order of responses is not guaranteed, sequential
/// `AssistResponse.audio_out` messages will always contain sequential portions
/// of audio.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task Assist(grpc::IAsyncStreamReader <global::Google.Assistant.Embedded.V1Alpha2.AssistRequest> requestStream, grpc::IServerStreamWriter <global::Google.Assistant.Embedded.V1Alpha2.AssistResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Streaming read of log entries as they are ingested. Until the stream is
/// terminated, it will continue reading logs.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task TailLogEntries(grpc::IAsyncStreamReader <global::Google.Cloud.Logging.V2.TailLogEntriesRequest> requestStream, grpc::IServerStreamWriter <global::Google.Cloud.Logging.V2.TailLogEntriesResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task <global::EventMonitor.Grpc.Acknowledgement> PushStream(grpc::IAsyncStreamReader <global::EventMonitor.Grpc.Event> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task TalkAndListen(grpc::IAsyncStreamReader <global::Chat.Grpc.ChatMessage> requestStream, grpc::IServerStreamWriter <global::Chat.Grpc.ChatMessage> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task ListPerson4(grpc::IAsyncStreamReader <global::Grpctest.Persion> requestStream, grpc::IServerStreamWriter <global::Grpctest.Persion> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Stream endpoint that receives 10 DummyMessages and replies with the last received one
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>The response to send back to the client (wrapped by a task).</returns>
public virtual global::System.Threading.Tasks.Task <global::Grpcbin.DummyMessage> DummyClientStream(grpc::IAsyncStreamReader <global::Grpcbin.DummyMessage> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Stream endpoint that sends back a received DummyMessage indefinitely (chat mode)
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task DummyBidirectionalStreamStream(grpc::IAsyncStreamReader <global::Grpcbin.DummyMessage> requestStream, grpc::IServerStreamWriter <global::Grpcbin.DummyMessage> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// 1. Envoy starts up and if its can_healthcheck option in the static
/// bootstrap config is enabled, sends HealthCheckRequest to the management
/// server. It supplies its capabilities (which protocol it can health check
/// with, what zone it resides in, etc.).
/// 2. In response to (1), the management server designates this Envoy as a
/// healthchecker to health check a subset of all upstream hosts for a given
/// cluster (for example upstream Host 1 and Host 2). It streams
/// HealthCheckSpecifier messages with cluster related configuration for all
/// clusters this Envoy is designated to health check. Subsequent
/// HealthCheckSpecifier message will be sent on changes to:
/// a. Endpoints to health checks
/// b. Per cluster configuration change
/// 3. Envoy creates a health probe based on the HealthCheck config and sends
/// it to endpoint(ip:port) of Host 1 and 2. Based on the HealthCheck
/// configuration Envoy waits upon the arrival of the probe response and
/// looks at the content of the response to decide whether the endpoint is
/// healthy or not. If a response hasn’t been received within the timeout
/// interval, the endpoint health status is considered TIMEOUT.
/// 4. Envoy reports results back in an EndpointHealthResponse message.
/// Envoy streams responses as often as the interval configured by the
/// management server in HealthCheckSpecifier.
/// 5. The management Server collects health statuses for all endpoints in the
/// cluster (for all clusters) and uses this information to construct
/// EndpointDiscoveryResponse messages.
/// 6. Once Envoy has a list of upstream endpoints to send traffic to, it load
/// balances traffic to them without additional health checking. It may
/// use inline healthcheck (i.e. consider endpoint UNHEALTHY if connection
/// failed to a particular endpoint to account for health status propagation
/// delay between HDS and EDS).
/// By default, can_healthcheck is true. If can_healthcheck is false, Cluster
/// configuration may not contain HealthCheck message.
/// TODO(htuch): How is can_healthcheck communicated to CDS to ensure the above
/// invariant?
/// TODO(htuch): Add @amb67's diagram.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task StreamHealthCheck(grpc::IAsyncStreamReader <global::Envoy.Service.Discovery.V2.HealthCheckRequestOrEndpointHealthResponse> requestStream, grpc::IServerStreamWriter <global::Envoy.Service.Discovery.V2.HealthCheckSpecifier> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task DrawPoints(grpc::IAsyncStreamReader <global::gRPCServer.DrawPointRequest> requestStream, grpc::IServerStreamWriter <global::gRPCServer.DrawPoint> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Processes a natural language query in audio format in a streaming fashion
/// and returns structured, actionable data as a result. This method is only
/// available via the gRPC API (not REST).
///
/// Note: Always use agent versions for production traffic.
/// See [Versions and
/// environments](https://cloud.google.com/dialogflow/es/docs/agents-versions).
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task StreamingDetectIntent(grpc::IAsyncStreamReader <global::Google.Cloud.Dialogflow.V2.StreamingDetectIntentRequest> requestStream, grpc::IServerStreamWriter <global::Google.Cloud.Dialogflow.V2.StreamingDetectIntentResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task SaveAll(grpc::IAsyncStreamReader <global::GrpcServer.Web.Protos.EmployeeRequest> requestStream, grpc::IServerStreamWriter <global::GrpcServer.Web.Protos.EmployeeResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task DuplexStreamingServerMethod(grpc::IAsyncStreamReader <global::Proxy.Grpc.StreamBuffer> requestStream, grpc::IServerStreamWriter <global::Proxy.Grpc.StreamBuffer> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Performs bidirectional streaming speech recognition: receive results while
/// sending audio. This method is only available via the gRPC API (not REST).
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task StreamingRecognize(grpc::IAsyncStreamReader <global::Google.Cloud.Speech.V1.StreamingRecognizeRequest> requestStream, grpc::IServerStreamWriter <global::Google.Cloud.Speech.V1.StreamingRecognizeResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
//// Requests a script to be evaluated as specified in the header.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task EvaluateScript(grpc::IAsyncStreamReader <global::Qlik.Sse.BundledRows> requestStream, grpc::IServerStreamWriter <global::Qlik.Sse.BundledRows> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task SayHello(grpc::IAsyncStreamReader <global::SnippetsShared.SnippetRequest> requestStream, grpc::IServerStreamWriter <global::SnippetsShared.SnippetResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Sum sums a stream of numbers, returning the final result once the stream
/// is closed.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>The response to send back to the client (wrapped by a task).</returns>
public virtual global::System.Threading.Tasks.Task <global::Math.Num> Sum(grpc::IAsyncStreamReader <global::Math.Num> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task UserExchange(grpc::IAsyncStreamReader <global::DowntownRealty.UserRequest> requestStream, grpc::IServerStreamWriter <global::DowntownRealty.UserResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// DivMany accepts an arbitrary number of division args from the client stream
/// and sends back the results in the reply stream. The stream continues until
/// the client closes its end; the server does the same after sending all the
/// replies. The stream ends immediately if either end aborts.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task DivMany(grpc::IAsyncStreamReader <global::Math.DivArgs> requestStream, grpc::IServerStreamWriter <global::Math.DivReply> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
///Bi-Directional Streaming Service
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task GreetFullStream(grpc::IAsyncStreamReader <global::GreetPackage.GreetRequest> requestStream, grpc::IServerStreamWriter <global::GreetPackage.GreetResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task Stream(grpc::IAsyncStreamReader <global::Axiverse.Services.Proto.ClientEvent> requestStream, grpc::IServerStreamWriter <global::Axiverse.Services.Proto.ServerEvent> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Advanced API to allow for multi-dimensional load balancing by remote
/// server. For receiving LB assignments, the steps are:
/// 1, The management server is configured with per cluster/zone/load metric
/// capacity configuration. The capacity configuration definition is
/// outside of the scope of this document.
/// 2. Envoy issues a standard {Stream,Fetch}Endpoints request for the clusters
/// to balance.
///
/// Independently, Envoy will initiate a StreamLoadStats bidi stream with a
/// management server:
/// 1. Once a connection establishes, the management server publishes a
/// LoadStatsResponse for all clusters it is interested in learning load
/// stats about.
/// 2. For each cluster, Envoy load balances incoming traffic to upstream hosts
/// based on per-zone weights and/or per-instance weights (if specified)
/// based on intra-zone LbPolicy. This information comes from the above
/// {Stream,Fetch}Endpoints.
/// 3. When upstream hosts reply, they optionally add header <define header
/// name> with ASCII representation of EndpointLoadMetricStats.
/// 4. Envoy aggregates load reports over the period of time given to it in
/// LoadStatsResponse.load_reporting_interval. This includes aggregation
/// stats Envoy maintains by itself (total_requests, rpc_errors etc.) as
/// well as load metrics from upstream hosts.
/// 5. When the timer of load_reporting_interval expires, Envoy sends new
/// LoadStatsRequest filled with load reports for each cluster.
/// 6. The management server uses the load reports from all reported Envoys
/// from around the world, computes global assignment and prepares traffic
/// assignment destined for each zone Envoys are located in. Goto 2.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="responseStream">Used for sending responses back to the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>A task indicating completion of the handler.</returns>
public virtual global::System.Threading.Tasks.Task StreamLoadStats(grpc::IAsyncStreamReader <global::Envoy.Service.LoadStats.V2.LoadStatsRequest> requestStream, grpc::IServerStreamWriter <global::Envoy.Service.LoadStats.V2.LoadStatsResponse> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task Register(grpc::IAsyncStreamReader <global::Chaincode.NET.Protos.ChaincodeMessage> requestStream, grpc::IServerStreamWriter <global::Chaincode.NET.Protos.ChaincodeMessage> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// A client-to-server streaming RPC.
///
/// Accepts a stream of Points on a route being traversed, returning a
/// RouteSummary when traversal is completed.
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>The response to send back to the client (wrapped by a task).</returns>
public virtual global::System.Threading.Tasks.Task <global::Routeguide.RouteSummary> RecordRoute(grpc::IAsyncStreamReader <global::Routeguide.Point> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
///ClientStreaming
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>The response to send back to the client (wrapped by a task).</returns>
public virtual global::System.Threading.Tasks.Task <global::GrpcServer.Web.Protos.AddPhotoResponse> AddPhoto(grpc::IAsyncStreamReader <global::GrpcServer.Web.Protos.AddPhotoRequest> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
public virtual global::System.Threading.Tasks.Task RecongnizationByFace(grpc::IAsyncStreamReader <global::Proprietor.InformationService.FaceRequest> requestStream, grpc::IServerStreamWriter <global::Proprietor.InformationService.FaceReply> responseStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}
/// <summary>
/// Unary
/// rpc UnaryCall (ExampleRequest) returns (ExampleResponse);
/// Server streaming
/// rpc StreamingFromServer (ExampleRequest) returns (stream ExampleResponse);
/// Client streaming
/// rpc StreamingFromClient (stream ExampleRequest) returns (ExampleResponse);
/// Bi-directional streaming
/// rpc StreamingBothWays (stream ExampleRequest) returns (stream ExampleResponse);
/// </summary>
/// <param name="requestStream">Used for reading requests from the client.</param>
/// <param name="context">The context of the server-side call handler being invoked.</param>
/// <returns>The response to send back to the client (wrapped by a task).</returns>
public virtual global::System.Threading.Tasks.Task <global::GrpcGreeter.CustomerAddedResult> AddCustomers(grpc::IAsyncStreamReader <global::GrpcGreeter.CustomerModel> requestStream, grpc::ServerCallContext context)
{
throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
}