docs: static <WReqT, WRespT> ClientInterceptor wrapClientInterceptor(
        final ClientInterceptor interceptor,
        final Marshaller<WReqT> reqMarshaller,
        final Marshaller<WRespT> respMarshaller) {
      return new ClientInterceptor() {
        @Override
        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
            final MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
          final MethodDescriptor<WReqT, WRespT> wrappedMethod =
              method.toBuilder(reqMarshaller, respMarshaller).build();
          final ClientCall<WReqT, WRespT> wrappedCall =
              interceptor.interceptCall(wrappedMethod, callOptions, next);
          return new PartialForwardingClientCall<ReqT, RespT>() {
            @Override
            public void start(final Listener<RespT> responseListener, Metadata headers) {
              wrappedCall.start(new PartialForwardingClientCallListener<WRespT>() {
                @Override
                public void onMessage(WRespT wMessage) {
                  InputStream bytes = respMarshaller.stream(wMessage);
                  RespT message = method.getResponseMarshaller().parse(bytes);
                  responseListener.onMessage(message);
                }
  
                @Override
                protected Listener<?> delegate() {
                  return responseListener;
                }
              }, headers);
            }
  
            @Override
            public void sendMessage(ReqT message) {
              InputStream bytes = method.getRequestMarshaller().stream(message);
              WReqT wReq = reqMarshaller.parse(bytes);
              wrappedCall.sendMessage(wReq);
            }
  
            @Override
            protected ClientCall<?, ?> delegate() {
              return wrappedCall;
            }
          };
        }
      };
    }