grpc-swift/Sources/performance-worker/Generated/grpc_testing_benchmark_service.grpc.swift

// Copyright 2015 gRPC authors.
//
// Licensed 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.

/// An integration test service that covers all the method signature permutations
/// of unary/streaming requests/responses.

// DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by the gRPC Swift generator plugin for the protocol buffer compiler.
// Source: grpc/testing/benchmark_service.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/grpc/grpc-swift

import GRPCCore
import GRPCProtobuf

internal enum Grpc_Testing_BenchmarkService {
    internal static let descriptor = GRPCCore.ServiceDescriptor.grpc_testing_BenchmarkService
    internal enum Method {
        internal enum UnaryCall {
            internal typealias Input = Grpc_Testing_SimpleRequest
            internal typealias Output = Grpc_Testing_SimpleResponse
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Grpc_Testing_BenchmarkService.descriptor.fullyQualifiedService,
                method: "UnaryCall"
            )
        }
        internal enum StreamingCall {
            internal typealias Input = Grpc_Testing_SimpleRequest
            internal typealias Output = Grpc_Testing_SimpleResponse
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Grpc_Testing_BenchmarkService.descriptor.fullyQualifiedService,
                method: "StreamingCall"
            )
        }
        internal enum StreamingFromClient {
            internal typealias Input = Grpc_Testing_SimpleRequest
            internal typealias Output = Grpc_Testing_SimpleResponse
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Grpc_Testing_BenchmarkService.descriptor.fullyQualifiedService,
                method: "StreamingFromClient"
            )
        }
        internal enum StreamingFromServer {
            internal typealias Input = Grpc_Testing_SimpleRequest
            internal typealias Output = Grpc_Testing_SimpleResponse
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Grpc_Testing_BenchmarkService.descriptor.fullyQualifiedService,
                method: "StreamingFromServer"
            )
        }
        internal enum StreamingBothWays {
            internal typealias Input = Grpc_Testing_SimpleRequest
            internal typealias Output = Grpc_Testing_SimpleResponse
            internal static let descriptor = GRPCCore.MethodDescriptor(
                service: Grpc_Testing_BenchmarkService.descriptor.fullyQualifiedService,
                method: "StreamingBothWays"
            )
        }
        internal static let descriptors: [GRPCCore.MethodDescriptor] = [
            UnaryCall.descriptor,
            StreamingCall.descriptor,
            StreamingFromClient.descriptor,
            StreamingFromServer.descriptor,
            StreamingBothWays.descriptor
        ]
    }
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias StreamingServiceProtocol = Grpc_Testing_BenchmarkServiceStreamingServiceProtocol
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias ServiceProtocol = Grpc_Testing_BenchmarkServiceServiceProtocol
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias ClientProtocol = Grpc_Testing_BenchmarkServiceClientProtocol
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal typealias Client = Grpc_Testing_BenchmarkServiceClient
}

extension GRPCCore.ServiceDescriptor {
    internal static let grpc_testing_BenchmarkService = Self(
        package: "grpc.testing",
        service: "BenchmarkService"
    )
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal protocol Grpc_Testing_BenchmarkServiceStreamingServiceProtocol: GRPCCore.RegistrableRPCService {
    /// One request followed by one response.
    /// The server returns the client payload as-is.
    func unaryCall(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
    
    /// Repeated sequence of one request followed by one response.
    /// Should be called streaming ping-pong
    /// The server returns the client payload as-is on each response
    func streamingCall(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
    
    /// Single-sided unbounded streaming from client to server
    /// The server returns the client payload as-is once the client does WritesDone
    func streamingFromClient(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
    
    /// Single-sided unbounded streaming from server to client
    /// The server repeatedly returns the client payload as-is
    func streamingFromServer(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
    
    /// Two-sided unbounded streaming between server to client
    /// Both sides send the content of their own choice to the other
    func streamingBothWays(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
}

/// Conformance to `GRPCCore.RegistrableRPCService`.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Grpc_Testing_BenchmarkService.StreamingServiceProtocol {
    @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
    internal func registerMethods(with router: inout GRPCCore.RPCRouter) {
        router.registerHandler(
            forMethod: Grpc_Testing_BenchmarkService.Method.UnaryCall.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleResponse>(),
            handler: { request, context in
                try await self.unaryCall(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Grpc_Testing_BenchmarkService.Method.StreamingCall.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleResponse>(),
            handler: { request, context in
                try await self.streamingCall(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Grpc_Testing_BenchmarkService.Method.StreamingFromClient.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleResponse>(),
            handler: { request, context in
                try await self.streamingFromClient(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Grpc_Testing_BenchmarkService.Method.StreamingFromServer.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleResponse>(),
            handler: { request, context in
                try await self.streamingFromServer(
                    request: request,
                    context: context
                )
            }
        )
        router.registerHandler(
            forMethod: Grpc_Testing_BenchmarkService.Method.StreamingBothWays.descriptor,
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleRequest>(),
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleResponse>(),
            handler: { request, context in
                try await self.streamingBothWays(
                    request: request,
                    context: context
                )
            }
        )
    }
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal protocol Grpc_Testing_BenchmarkServiceServiceProtocol: Grpc_Testing_BenchmarkService.StreamingServiceProtocol {
    /// One request followed by one response.
    /// The server returns the client payload as-is.
    func unaryCall(
        request: GRPCCore.ServerRequest.Single<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Single<Grpc_Testing_SimpleResponse>
    
    /// Repeated sequence of one request followed by one response.
    /// Should be called streaming ping-pong
    /// The server returns the client payload as-is on each response
    func streamingCall(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
    
    /// Single-sided unbounded streaming from client to server
    /// The server returns the client payload as-is once the client does WritesDone
    func streamingFromClient(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Single<Grpc_Testing_SimpleResponse>
    
    /// Single-sided unbounded streaming from server to client
    /// The server repeatedly returns the client payload as-is
    func streamingFromServer(
        request: GRPCCore.ServerRequest.Single<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
    
    /// Two-sided unbounded streaming between server to client
    /// Both sides send the content of their own choice to the other
    func streamingBothWays(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse>
}

/// Partial conformance to `Grpc_Testing_BenchmarkServiceStreamingServiceProtocol`.
@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Grpc_Testing_BenchmarkService.ServiceProtocol {
    internal func unaryCall(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse> {
        let response = try await self.unaryCall(
            request: GRPCCore.ServerRequest.Single(stream: request),
            context: context
        )
        return GRPCCore.ServerResponse.Stream(single: response)
    }
    
    internal func streamingFromClient(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse> {
        let response = try await self.streamingFromClient(
            request: request,
            context: context
        )
        return GRPCCore.ServerResponse.Stream(single: response)
    }
    
    internal func streamingFromServer(
        request: GRPCCore.ServerRequest.Stream<Grpc_Testing_SimpleRequest>,
        context: GRPCCore.ServerContext
    ) async throws -> GRPCCore.ServerResponse.Stream<Grpc_Testing_SimpleResponse> {
        let response = try await self.streamingFromServer(
            request: GRPCCore.ServerRequest.Single(stream: request),
            context: context
        )
        return response
    }
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal protocol Grpc_Testing_BenchmarkServiceClientProtocol: Sendable {
    /// One request followed by one response.
    /// The server returns the client payload as-is.
    func unaryCall<R>(
        request: GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// Repeated sequence of one request followed by one response.
    /// Should be called streaming ping-pong
    /// The server returns the client payload as-is on each response
    func streamingCall<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// Single-sided unbounded streaming from client to server
    /// The server returns the client payload as-is once the client does WritesDone
    func streamingFromClient<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// Single-sided unbounded streaming from server to client
    /// The server repeatedly returns the client payload as-is
    func streamingFromServer<R>(
        request: GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable
    
    /// Two-sided unbounded streaming between server to client
    /// Both sides send the content of their own choice to the other
    func streamingBothWays<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Grpc_Testing_BenchmarkService.ClientProtocol {
    internal func unaryCall<R>(
        request: GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.unaryCall(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleResponse>(),
            options: options,
            body
        )
    }
    
    internal func streamingCall<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.streamingCall(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleResponse>(),
            options: options,
            body
        )
    }
    
    internal func streamingFromClient<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.streamingFromClient(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleResponse>(),
            options: options,
            body
        )
    }
    
    internal func streamingFromServer<R>(
        request: GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.streamingFromServer(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleResponse>(),
            options: options,
            body
        )
    }
    
    internal func streamingBothWays<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.streamingBothWays(
            request: request,
            serializer: GRPCProtobuf.ProtobufSerializer<Grpc_Testing_SimpleRequest>(),
            deserializer: GRPCProtobuf.ProtobufDeserializer<Grpc_Testing_SimpleResponse>(),
            options: options,
            body
        )
    }
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
extension Grpc_Testing_BenchmarkService.ClientProtocol {
    /// One request followed by one response.
    /// The server returns the client payload as-is.
    internal func unaryCall<Result>(
        _ message: Grpc_Testing_SimpleRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> Result = {
            try $0.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.unaryCall(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// Repeated sequence of one request followed by one response.
    /// Should be called streaming ping-pong
    /// The server returns the client payload as-is on each response
    internal func streamingCall<Result>(
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Grpc_Testing_SimpleRequest>) async throws -> Void,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>(
            metadata: metadata,
            producer: requestProducer
        )
        return try await self.streamingCall(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// Single-sided unbounded streaming from client to server
    /// The server returns the client payload as-is once the client does WritesDone
    internal func streamingFromClient<Result>(
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Grpc_Testing_SimpleRequest>) async throws -> Void,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> Result = {
            try $0.message
        }
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>(
            metadata: metadata,
            producer: requestProducer
        )
        return try await self.streamingFromClient(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// Single-sided unbounded streaming from server to client
    /// The server repeatedly returns the client payload as-is
    internal func streamingFromServer<Result>(
        _ message: Grpc_Testing_SimpleRequest,
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>(
            message: message,
            metadata: metadata
        )
        return try await self.streamingFromServer(
            request: request,
            options: options,
            handleResponse
        )
    }
    
    /// Two-sided unbounded streaming between server to client
    /// Both sides send the content of their own choice to the other
    internal func streamingBothWays<Result>(
        metadata: GRPCCore.Metadata = [:],
        options: GRPCCore.CallOptions = .defaults,
        requestProducer: @Sendable @escaping (GRPCCore.RPCWriter<Grpc_Testing_SimpleRequest>) async throws -> Void,
        onResponse handleResponse: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> Result
    ) async throws -> Result where Result: Sendable {
        let request = GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>(
            metadata: metadata,
            producer: requestProducer
        )
        return try await self.streamingBothWays(
            request: request,
            options: options,
            handleResponse
        )
    }
}

@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
internal struct Grpc_Testing_BenchmarkServiceClient: Grpc_Testing_BenchmarkService.ClientProtocol {
    private let client: GRPCCore.GRPCClient
    
    internal init(wrapping client: GRPCCore.GRPCClient) {
        self.client = client
    }
    
    /// One request followed by one response.
    /// The server returns the client payload as-is.
    internal func unaryCall<R>(
        request: GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.client.unary(
            request: request,
            descriptor: Grpc_Testing_BenchmarkService.Method.UnaryCall.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// Repeated sequence of one request followed by one response.
    /// Should be called streaming ping-pong
    /// The server returns the client payload as-is on each response
    internal func streamingCall<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.client.bidirectionalStreaming(
            request: request,
            descriptor: Grpc_Testing_BenchmarkService.Method.StreamingCall.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// Single-sided unbounded streaming from client to server
    /// The server returns the client payload as-is once the client does WritesDone
    internal func streamingFromClient<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Single<Grpc_Testing_SimpleResponse>) async throws -> R = {
            try $0.message
        }
    ) async throws -> R where R: Sendable {
        try await self.client.clientStreaming(
            request: request,
            descriptor: Grpc_Testing_BenchmarkService.Method.StreamingFromClient.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// Single-sided unbounded streaming from server to client
    /// The server repeatedly returns the client payload as-is
    internal func streamingFromServer<R>(
        request: GRPCCore.ClientRequest.Single<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.client.serverStreaming(
            request: request,
            descriptor: Grpc_Testing_BenchmarkService.Method.StreamingFromServer.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
    
    /// Two-sided unbounded streaming between server to client
    /// Both sides send the content of their own choice to the other
    internal func streamingBothWays<R>(
        request: GRPCCore.ClientRequest.Stream<Grpc_Testing_SimpleRequest>,
        serializer: some GRPCCore.MessageSerializer<Grpc_Testing_SimpleRequest>,
        deserializer: some GRPCCore.MessageDeserializer<Grpc_Testing_SimpleResponse>,
        options: GRPCCore.CallOptions = .defaults,
        _ body: @Sendable @escaping (GRPCCore.ClientResponse.Stream<Grpc_Testing_SimpleResponse>) async throws -> R
    ) async throws -> R where R: Sendable {
        try await self.client.bidirectionalStreaming(
            request: request,
            descriptor: Grpc_Testing_BenchmarkService.Method.StreamingBothWays.descriptor,
            serializer: serializer,
            deserializer: deserializer,
            options: options,
            handler: body
        )
    }
}