gen-py3/module/clients_wrapper.cpp

/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */

#include <src/gen-py3/module/clients_wrapper.h>

namespace some {
namespace valid {
namespace ns {


folly::Future<folly::Unit>
ReturnServiceClientWrapper::noReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_noReturn, channel_);
  client->noReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<bool>
ReturnServiceClientWrapper::boolReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<bool> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<bool>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_boolReturn, channel_);
  client->boolReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<int16_t>
ReturnServiceClientWrapper::i16Return(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<int16_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int16_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_i16Return, channel_);
  client->i16Return(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<int32_t>
ReturnServiceClientWrapper::i32Return(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<int32_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int32_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_i32Return, channel_);
  client->i32Return(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<int64_t>
ReturnServiceClientWrapper::i64Return(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<int64_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int64_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_i64Return, channel_);
  client->i64Return(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<float>
ReturnServiceClientWrapper::floatReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<float> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<float>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_floatReturn, channel_);
  client->floatReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<double>
ReturnServiceClientWrapper::doubleReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<double> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<double>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_doubleReturn, channel_);
  client->doubleReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::string>
ReturnServiceClientWrapper::stringReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::string> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::string>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_stringReturn, channel_);
  client->stringReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::string>
ReturnServiceClientWrapper::binaryReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::string> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::string>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_binaryReturn, channel_);
  client->binaryReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::map<std::string,int64_t>>
ReturnServiceClientWrapper::mapReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::map<std::string,int64_t>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::map<std::string,int64_t>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_mapReturn, channel_);
  client->mapReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<int32_t>
ReturnServiceClientWrapper::simpleTypedefReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<int32_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int32_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_simpleTypedefReturn, channel_);
  client->simpleTypedefReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>>
ReturnServiceClientWrapper::complexTypedefReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_complexTypedefReturn, channel_);
  client->complexTypedefReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::vector<std::vector<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>>>>
ReturnServiceClientWrapper::list_mostComplexTypedefReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<std::vector<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>>>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<std::vector<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>>>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_list_mostComplexTypedefReturn, channel_);
  client->list_mostComplexTypedefReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<::some::valid::ns::MyEnumA>
ReturnServiceClientWrapper::enumReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::MyEnumA> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::MyEnumA>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_enumReturn, channel_);
  client->enumReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::vector<::some::valid::ns::MyEnumA>>
ReturnServiceClientWrapper::list_EnumReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<::some::valid::ns::MyEnumA>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<::some::valid::ns::MyEnumA>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_list_EnumReturn, channel_);
  client->list_EnumReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<::some::valid::ns::MyStruct>
ReturnServiceClientWrapper::structReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::MyStruct> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::MyStruct>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_structReturn, channel_);
  client->structReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::set<::some::valid::ns::MyStruct>>
ReturnServiceClientWrapper::set_StructReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::set<::some::valid::ns::MyStruct>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::set<::some::valid::ns::MyStruct>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_set_StructReturn, channel_);
  client->set_StructReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<::some::valid::ns::ComplexUnion>
ReturnServiceClientWrapper::unionReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::ComplexUnion> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::ComplexUnion>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_unionReturn, channel_);
  client->unionReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<std::vector<::some::valid::ns::ComplexUnion>>
ReturnServiceClientWrapper::list_UnionReturn(
    apache::thrift::RpcOptions& rpcOptions) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<::some::valid::ns::ComplexUnion>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<::some::valid::ns::ComplexUnion>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_list_UnionReturn, channel_);
  client->list_UnionReturn(
    rpcOptions,
    std::move(callback)
  );
  return _future;
}

folly::Future<folly::IOBuf>
ReturnServiceClientWrapper::readDataEb(
    apache::thrift::RpcOptions& rpcOptions,
    int64_t arg_size) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::IOBuf> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::IOBuf>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_readDataEb, channel_);
  client->readDataEb(
    rpcOptions,
    std::move(callback),
    arg_size
  );
  return _future;
}

folly::Future<std::unique_ptr<folly::IOBuf>>
ReturnServiceClientWrapper::readData(
    apache::thrift::RpcOptions& rpcOptions,
    int64_t arg_size) {
  auto* client = static_cast<::some::valid::ns::ReturnServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::unique_ptr<folly::IOBuf>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::unique_ptr<folly::IOBuf>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_readData, channel_);
  client->readData(
    rpcOptions,
    std::move(callback),
    arg_size
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_i16_param(
    apache::thrift::RpcOptions& rpcOptions,
    int16_t arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_i16_param, channel_);
  client->void_ret_i16_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_byte_i16_param(
    apache::thrift::RpcOptions& rpcOptions,
    int8_t arg_param1,
    int16_t arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_byte_i16_param, channel_);
  client->void_ret_byte_i16_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_map_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::map<std::string,int64_t> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_map_param, channel_);
  client->void_ret_map_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_map_setlist_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::map<std::string,int64_t> arg_param1,
    std::set<std::vector<std::string>> arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_map_setlist_param, channel_);
  client->void_ret_map_setlist_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_map_typedef_param(
    apache::thrift::RpcOptions& rpcOptions,
    int32_t arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_map_typedef_param, channel_);
  client->void_ret_map_typedef_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_enum_param(
    apache::thrift::RpcOptions& rpcOptions,
    ::some::valid::ns::MyEnumA arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_enum_param, channel_);
  client->void_ret_enum_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_struct_param(
    apache::thrift::RpcOptions& rpcOptions,
    ::some::valid::ns::MyStruct arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_struct_param, channel_);
  client->void_ret_struct_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<folly::Unit>
ParamServiceClientWrapper::void_ret_listunion_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::vector<::some::valid::ns::ComplexUnion> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<folly::Unit> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<folly::Unit>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_void_ret_listunion_param, channel_);
  client->void_ret_listunion_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<bool>
ParamServiceClientWrapper::bool_ret_i32_i64_param(
    apache::thrift::RpcOptions& rpcOptions,
    int32_t arg_param1,
    int64_t arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<bool> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<bool>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_bool_ret_i32_i64_param, channel_);
  client->bool_ret_i32_i64_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<bool>
ParamServiceClientWrapper::bool_ret_map_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::map<std::string,int64_t> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<bool> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<bool>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_bool_ret_map_param, channel_);
  client->bool_ret_map_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<bool>
ParamServiceClientWrapper::bool_ret_union_param(
    apache::thrift::RpcOptions& rpcOptions,
    ::some::valid::ns::ComplexUnion arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<bool> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<bool>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_bool_ret_union_param, channel_);
  client->bool_ret_union_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<int64_t>
ParamServiceClientWrapper::i64_ret_float_double_param(
    apache::thrift::RpcOptions& rpcOptions,
    float arg_param1,
    double arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<int64_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int64_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_i64_ret_float_double_param, channel_);
  client->i64_ret_float_double_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<int64_t>
ParamServiceClientWrapper::i64_ret_string_typedef_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::string arg_param1,
    std::set<std::vector<std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>>>> arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<int64_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int64_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_i64_ret_string_typedef_param, channel_);
  client->i64_ret_string_typedef_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<int64_t>
ParamServiceClientWrapper::i64_ret_i32_i32_i32_i32_i32_param(
    apache::thrift::RpcOptions& rpcOptions,
    int32_t arg_param1,
    int32_t arg_param2,
    int32_t arg_param3,
    int32_t arg_param4,
    int32_t arg_param5) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<int64_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int64_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_i64_ret_i32_i32_i32_i32_i32_param, channel_);
  client->i64_ret_i32_i32_i32_i32_i32_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2,
    arg_param3,
    arg_param4,
    arg_param5
  );
  return _future;
}

folly::Future<double>
ParamServiceClientWrapper::double_ret_setstruct_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::set<::some::valid::ns::MyStruct> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<double> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<double>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_double_ret_setstruct_param, channel_);
  client->double_ret_setstruct_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<std::string>
ParamServiceClientWrapper::string_ret_string_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::string arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::string> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::string>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_string_ret_string_param, channel_);
  client->string_ret_string_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<std::string>
ParamServiceClientWrapper::binary_ret_binary_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::string arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::string> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::string>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_binary_ret_binary_param, channel_);
  client->binary_ret_binary_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<std::map<std::string,int64_t>>
ParamServiceClientWrapper::map_ret_bool_param(
    apache::thrift::RpcOptions& rpcOptions,
    bool arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::map<std::string,int64_t>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::map<std::string,int64_t>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_map_ret_bool_param, channel_);
  client->map_ret_bool_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<std::vector<bool>>
ParamServiceClientWrapper::list_ret_map_setlist_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::map<int32_t,std::vector<std::string>> arg_param1,
    std::vector<std::string> arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<bool>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<bool>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_list_ret_map_setlist_param, channel_);
  client->list_ret_map_setlist_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<std::map<std::set<std::vector<int32_t>>,std::map<std::vector<std::set<std::string>>,std::string>>>
ParamServiceClientWrapper::mapsetlistmapliststring_ret_listlistlist_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::vector<std::vector<std::vector<std::vector<int32_t>>>> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::map<std::set<std::vector<int32_t>>,std::map<std::vector<std::set<std::string>>,std::string>>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::map<std::set<std::vector<int32_t>>,std::map<std::vector<std::set<std::string>>,std::string>>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_mapsetlistmapliststring_ret_listlistlist_param, channel_);
  client->mapsetlistmapliststring_ret_listlistlist_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<int32_t>
ParamServiceClientWrapper::typedef_ret_i32_param(
    apache::thrift::RpcOptions& rpcOptions,
    int32_t arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<int32_t> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<int32_t>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_typedef_ret_i32_param, channel_);
  client->typedef_ret_i32_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<std::vector<int32_t>>
ParamServiceClientWrapper::listtypedef_ret_typedef_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::vector<std::map<::some::valid::ns::Empty,::some::valid::ns::MyStruct>> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<int32_t>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<int32_t>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_listtypedef_ret_typedef_param, channel_);
  client->listtypedef_ret_typedef_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<::some::valid::ns::MyEnumA>
ParamServiceClientWrapper::enum_ret_double_param(
    apache::thrift::RpcOptions& rpcOptions,
    double arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::MyEnumA> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::MyEnumA>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_enum_ret_double_param, channel_);
  client->enum_ret_double_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<::some::valid::ns::MyEnumA>
ParamServiceClientWrapper::enum_ret_double_enum_param(
    apache::thrift::RpcOptions& rpcOptions,
    double arg_param1,
    ::some::valid::ns::MyEnumA arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::MyEnumA> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::MyEnumA>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_enum_ret_double_enum_param, channel_);
  client->enum_ret_double_enum_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<std::vector<::some::valid::ns::MyEnumA>>
ParamServiceClientWrapper::listenum_ret_map_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::map<std::string,int64_t> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<::some::valid::ns::MyEnumA>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<::some::valid::ns::MyEnumA>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_listenum_ret_map_param, channel_);
  client->listenum_ret_map_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<::some::valid::ns::MyStruct>
ParamServiceClientWrapper::struct_ret_i16_param(
    apache::thrift::RpcOptions& rpcOptions,
    int16_t arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::MyStruct> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::MyStruct>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_struct_ret_i16_param, channel_);
  client->struct_ret_i16_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<std::set<::some::valid::ns::MyStruct>>
ParamServiceClientWrapper::setstruct_ret_set_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::set<std::string> arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::set<::some::valid::ns::MyStruct>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::set<::some::valid::ns::MyStruct>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_setstruct_ret_set_param, channel_);
  client->setstruct_ret_set_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

folly::Future<::some::valid::ns::ComplexUnion>
ParamServiceClientWrapper::union_ret_i32_i32_param(
    apache::thrift::RpcOptions& rpcOptions,
    int32_t arg_param1,
    int32_t arg_param2) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<::some::valid::ns::ComplexUnion> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<::some::valid::ns::ComplexUnion>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_union_ret_i32_i32_param, channel_);
  client->union_ret_i32_i32_param(
    rpcOptions,
    std::move(callback),
    arg_param1,
    arg_param2
  );
  return _future;
}

folly::Future<std::vector<::some::valid::ns::ComplexUnion>>
ParamServiceClientWrapper::listunion_string_param(
    apache::thrift::RpcOptions& rpcOptions,
    std::string arg_param1) {
  auto* client = static_cast<::some::valid::ns::ParamServiceAsyncClient*>(async_client_.get());
  folly::Promise<std::vector<::some::valid::ns::ComplexUnion>> _promise;
  auto _future = _promise.getFuture();
  auto callback = std::make_unique<::thrift::py3::FutureCallback<std::vector<::some::valid::ns::ComplexUnion>>>(
    std::move(_promise), rpcOptions, client->recv_wrapped_listunion_string_param, channel_);
  client->listunion_string_param(
    rpcOptions,
    std::move(callback),
    arg_param1
  );
  return _future;
}

} // namespace some
} // namespace valid
} // namespace ns