/**
 * Autogenerated by Thrift for /opt/local/var/macports/build/fb303-3df6b803/work/fb303-2025.08.25.00/fb303/thrift/fb303_core.thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated @nocommit
 */
#pragma once

#include "fb303/thrift/gen-cpp2/BaseService.h"

#include <thrift/lib/cpp2/gen/service_tcc.h>

namespace facebook::fb303::cpp2 {
typedef apache::thrift::ThriftPresult<false> BaseService_getStatus_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::enumeration, ::facebook::fb303::cpp2::fb303_status*>> BaseService_getStatus_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_getName_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getName_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_getVersion_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getVersion_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_getStatusDetails_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getStatusDetails_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_getCounters_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, ::std::int64_t>*>> BaseService_getCounters_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getRegexCounters_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, ::std::int64_t>*>> BaseService_getRegexCounters_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::list<::apache::thrift::type_class::string>, ::std::vector<::std::string>*>> BaseService_getSelectedCounters_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, ::std::int64_t>*>> BaseService_getSelectedCounters_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getCounter_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::integral, ::std::int64_t*>> BaseService_getCounter_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_getExportedValues_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::string>, ::std::map<::std::string, ::std::string>*>> BaseService_getExportedValues_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::list<::apache::thrift::type_class::string>, ::std::vector<::std::string>*>> BaseService_getSelectedExportedValues_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::string>, ::std::map<::std::string, ::std::string>*>> BaseService_getSelectedExportedValues_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getRegexExportedValues_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::string>, ::std::map<::std::string, ::std::string>*>> BaseService_getRegexExportedValues_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getExportedValue_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getExportedValue_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::string, ::std::string*>, apache::thrift::FieldData<2, ::apache::thrift::type_class::string, ::std::string*>> BaseService_setOption_pargs;
typedef apache::thrift::ThriftPresult<true> BaseService_setOption_presult;
typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getOption_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::string, ::std::string*>> BaseService_getOption_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_getOptions_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::string>, ::std::map<::std::string, ::std::string>*>> BaseService_getOptions_presult;
typedef apache::thrift::ThriftPresult<false> BaseService_aliveSince_pargs;
typedef apache::thrift::ThriftPresult<true, apache::thrift::FieldData<0, ::apache::thrift::type_class::integral, ::std::int64_t*>> BaseService_aliveSince_presult;
//
// Service Methods
//

//
// Method 'getStatus'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getStatus(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getStatus<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getStatus(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getStatus_pargs pargs() {
      BaseService_getStatus_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getStatus",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getStatus",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getStatus");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getStatus",
      /* .qualifiedMethodName =*/ "BaseService.getStatus"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<::facebook::fb303::cpp2::fb303_status>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getStatus<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getStatus<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getStatus(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getStatus(
    apache::thrift::ContextStack* ctx,
    ::facebook::fb303::cpp2::fb303_status const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getStatus_presult result;
  result.get<0>().value = const_cast<::facebook::fb303::cpp2::fb303_status*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getStatus", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getStatus(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getStatus");
    return;
  }
}
//
// End of Method 'getStatus'
//

//
// Method 'getName'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getName(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::NORMAL);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getName<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getName(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getName_pargs pargs() {
      BaseService_getName_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getName",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getName",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getName");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getName",
      /* .qualifiedMethodName =*/ "BaseService.getName"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::string>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getName<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getName<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getName(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getName(
    apache::thrift::ContextStack* ctx,
    ::std::string const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getName_presult result;
  result.get<0>().value = const_cast<::std::string*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getName", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getName(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getName");
    return;
  }
}
//
// End of Method 'getName'
//

//
// Method 'getVersion'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getVersion(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::NORMAL);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getVersion<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getVersion(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getVersion_pargs pargs() {
      BaseService_getVersion_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getVersion",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getVersion",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getVersion");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getVersion",
      /* .qualifiedMethodName =*/ "BaseService.getVersion"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::string>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getVersion<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getVersion<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getVersion(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getVersion(
    apache::thrift::ContextStack* ctx,
    ::std::string const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getVersion_presult result;
  result.get<0>().value = const_cast<::std::string*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getVersion", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getVersion(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getVersion");
    return;
  }
}
//
// End of Method 'getVersion'
//

//
// Method 'getStatusDetails'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getStatusDetails(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getStatusDetails<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getStatusDetails(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getStatusDetails_pargs pargs() {
      BaseService_getStatusDetails_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getStatusDetails",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getStatusDetails",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getStatusDetails");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getStatusDetails",
      /* .qualifiedMethodName =*/ "BaseService.getStatusDetails"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::string>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getStatusDetails<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getStatusDetails<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getStatusDetails(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getStatusDetails(
    apache::thrift::ContextStack* ctx,
    ::std::string const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getStatusDetails_presult result;
  result.get<0>().value = const_cast<::std::string*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getStatusDetails", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getStatusDetails(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getStatusDetails");
    return;
  }
}
//
// End of Method 'getStatusDetails'
//

//
// Method 'getCounters'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getCounters(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, nullptr, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  if (!req->getShouldStartProcessing()) {
    apache::thrift::HandlerCallbackBase::releaseRequest(
        std::move(req),
        eb);
    return;
  }
  apache::thrift::ServerRequest serverRequest{
      std::move(req),
      std::move(serializedRequest),
      ctx,
      {},
      {},
      {},
      {}};
  executeRequest_getCounters<ProtocolIn_, ProtocolOut_>(std::move(serverRequest));
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getCounters(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getCounters_pargs pargs() {
      BaseService_getCounters_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getCounters",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getCounters",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getCounters");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getCounters",
      /* .qualifiedMethodName =*/ "BaseService.getCounters"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::int64_t>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getCounters<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getCounters<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          nullptr,
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_eb_getCounters(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getCounters(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::int64_t> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getCounters_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::int64_t>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getCounters", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getCounters(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getCounters");
    return;
  }
}
//
// End of Method 'getCounters'
//

//
// Method 'getRegexCounters'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getRegexCounters(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, nullptr, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  if (!req->getShouldStartProcessing()) {
    apache::thrift::HandlerCallbackBase::releaseRequest(
        std::move(req),
        eb);
    return;
  }
  apache::thrift::ServerRequest serverRequest{
      std::move(req),
      std::move(serializedRequest),
      ctx,
      {},
      {},
      {},
      {}};
  executeRequest_getRegexCounters<ProtocolIn_, ProtocolOut_>(std::move(serverRequest));
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getRegexCounters(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::string> uarg_regex = std::make_unique<::std::string>();
    BaseService_getRegexCounters_pargs pargs() {
      BaseService_getRegexCounters_pargs args;
      args.get<0>().value = uarg_regex.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_regex)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getRegexCounters",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getRegexCounters",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getRegexCounters");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getRegexCounters",
      /* .qualifiedMethodName =*/ "BaseService.getRegexCounters"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::int64_t>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getRegexCounters<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getRegexCounters<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          nullptr,
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_eb_getRegexCounters(std::move(cb), std::move(args.uarg_regex));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getRegexCounters(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::int64_t> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getRegexCounters_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::int64_t>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getRegexCounters", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getRegexCounters(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getRegexCounters");
    return;
  }
}
//
// End of Method 'getRegexCounters'
//

//
// Method 'getSelectedCounters'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getSelectedCounters(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, nullptr, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  if (!req->getShouldStartProcessing()) {
    apache::thrift::HandlerCallbackBase::releaseRequest(
        std::move(req),
        eb);
    return;
  }
  apache::thrift::ServerRequest serverRequest{
      std::move(req),
      std::move(serializedRequest),
      ctx,
      {},
      {},
      {},
      {}};
  executeRequest_getSelectedCounters<ProtocolIn_, ProtocolOut_>(std::move(serverRequest));
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getSelectedCounters(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::vector<::std::string>> uarg_keys = std::make_unique<::std::vector<::std::string>>();
    BaseService_getSelectedCounters_pargs pargs() {
      BaseService_getSelectedCounters_pargs args;
      args.get<0>().value = uarg_keys.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_keys)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getSelectedCounters",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getSelectedCounters",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getSelectedCounters");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getSelectedCounters",
      /* .qualifiedMethodName =*/ "BaseService.getSelectedCounters"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::int64_t>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getSelectedCounters<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getSelectedCounters<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          nullptr,
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_eb_getSelectedCounters(std::move(cb), std::move(args.uarg_keys));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getSelectedCounters(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::int64_t> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getSelectedCounters_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::int64_t>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getSelectedCounters", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getSelectedCounters(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getSelectedCounters");
    return;
  }
}
//
// End of Method 'getSelectedCounters'
//

//
// Method 'getCounter'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getCounter(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getCounter<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getCounter(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::string> uarg_key = std::make_unique<::std::string>();
    BaseService_getCounter_pargs pargs() {
      BaseService_getCounter_pargs args;
      args.get<0>().value = uarg_key.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_key)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getCounter",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getCounter",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getCounter");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getCounter",
      /* .qualifiedMethodName =*/ "BaseService.getCounter"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<::std::int64_t>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getCounter<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getCounter<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getCounter(std::move(cb), std::move(args.uarg_key));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getCounter(
    apache::thrift::ContextStack* ctx,
    ::std::int64_t const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getCounter_presult result;
  result.get<0>().value = const_cast<::std::int64_t*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getCounter", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getCounter(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getCounter");
    return;
  }
}
//
// End of Method 'getCounter'
//

//
// Method 'getExportedValues'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getExportedValues(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getExportedValues<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getExportedValues(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getExportedValues_pargs pargs() {
      BaseService_getExportedValues_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getExportedValues",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getExportedValues",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getExportedValues");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getExportedValues",
      /* .qualifiedMethodName =*/ "BaseService.getExportedValues"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::string>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getExportedValues<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getExportedValues<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getExportedValues(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getExportedValues(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::string> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getExportedValues_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::string>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getExportedValues", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getExportedValues(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getExportedValues");
    return;
  }
}
//
// End of Method 'getExportedValues'
//

//
// Method 'getSelectedExportedValues'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getSelectedExportedValues(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getSelectedExportedValues<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getSelectedExportedValues(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::vector<::std::string>> uarg_keys = std::make_unique<::std::vector<::std::string>>();
    BaseService_getSelectedExportedValues_pargs pargs() {
      BaseService_getSelectedExportedValues_pargs args;
      args.get<0>().value = uarg_keys.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_keys)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getSelectedExportedValues",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getSelectedExportedValues",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getSelectedExportedValues");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getSelectedExportedValues",
      /* .qualifiedMethodName =*/ "BaseService.getSelectedExportedValues"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::string>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getSelectedExportedValues<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getSelectedExportedValues<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getSelectedExportedValues(std::move(cb), std::move(args.uarg_keys));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getSelectedExportedValues(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::string> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getSelectedExportedValues_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::string>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getSelectedExportedValues", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getSelectedExportedValues(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getSelectedExportedValues");
    return;
  }
}
//
// End of Method 'getSelectedExportedValues'
//

//
// Method 'getRegexExportedValues'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getRegexExportedValues(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::NORMAL);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getRegexExportedValues<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getRegexExportedValues(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::string> uarg_regex = std::make_unique<::std::string>();
    BaseService_getRegexExportedValues_pargs pargs() {
      BaseService_getRegexExportedValues_pargs args;
      args.get<0>().value = uarg_regex.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_regex)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getRegexExportedValues",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getRegexExportedValues",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getRegexExportedValues");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getRegexExportedValues",
      /* .qualifiedMethodName =*/ "BaseService.getRegexExportedValues"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::string>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getRegexExportedValues<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getRegexExportedValues<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getRegexExportedValues(std::move(cb), std::move(args.uarg_regex));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getRegexExportedValues(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::string> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getRegexExportedValues_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::string>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getRegexExportedValues", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getRegexExportedValues(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getRegexExportedValues");
    return;
  }
}
//
// End of Method 'getRegexExportedValues'
//

//
// Method 'getExportedValue'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getExportedValue(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getExportedValue<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getExportedValue(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::string> uarg_key = std::make_unique<::std::string>();
    BaseService_getExportedValue_pargs pargs() {
      BaseService_getExportedValue_pargs args;
      args.get<0>().value = uarg_key.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_key)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getExportedValue",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getExportedValue",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getExportedValue");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getExportedValue",
      /* .qualifiedMethodName =*/ "BaseService.getExportedValue"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::string>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getExportedValue<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getExportedValue<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getExportedValue(std::move(cb), std::move(args.uarg_key));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getExportedValue(
    apache::thrift::ContextStack* ctx,
    ::std::string const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getExportedValue_presult result;
  result.get<0>().value = const_cast<::std::string*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getExportedValue", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getExportedValue(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getExportedValue");
    return;
  }
}
//
// End of Method 'getExportedValue'
//

//
// Method 'setOption'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_setOption(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::NORMAL);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_setOption<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_setOption(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::string> uarg_key = std::make_unique<::std::string>();
    std::unique_ptr<::std::string> uarg_value = std::make_unique<::std::string>();
    BaseService_setOption_pargs pargs() {
      BaseService_setOption_pargs args;
      args.get<0>().value = uarg_key.get();
      args.get<1>().value = uarg_value.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_key),
        std::as_const(*uarg_value)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.setOption",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "setOption",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "setOption");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "setOption",
      /* .qualifiedMethodName =*/ "BaseService.setOption"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<void>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_setOption<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_setOption<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_setOption(std::move(cb), std::move(args.uarg_key), std::move(args.uarg_value));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_setOption(
    apache::thrift::ContextStack* ctx) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_setOption_presult result;
  return serializeResponse("setOption", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_setOption(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "setOption");
    return;
  }
}
//
// End of Method 'setOption'
//

//
// Method 'getOption'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getOption(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::NORMAL);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getOption<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getOption(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    std::unique_ptr<::std::string> uarg_key = std::make_unique<::std::string>();
    BaseService_getOption_pargs pargs() {
      BaseService_getOption_pargs args;
      args.get<0>().value = uarg_key.get();
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
        std::as_const(*uarg_key)
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getOption",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getOption",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getOption");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getOption",
      /* .qualifiedMethodName =*/ "BaseService.getOption"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::string>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getOption<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getOption<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getOption(std::move(cb), std::move(args.uarg_key));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getOption(
    apache::thrift::ContextStack* ctx,
    ::std::string const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getOption_presult result;
  result.get<0>().value = const_cast<::std::string*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getOption", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getOption(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getOption");
    return;
  }
}
//
// End of Method 'getOption'
//

//
// Method 'getOptions'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_getOptions(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::NORMAL);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_getOptions<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_getOptions(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_getOptions_pargs pargs() {
      BaseService_getOptions_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.getOptions",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "getOptions",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "getOptions");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "getOptions",
      /* .qualifiedMethodName =*/ "BaseService.getOptions"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<std::unique_ptr<::std::map<::std::string, ::std::string>>>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_getOptions<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_getOptions<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_getOptions(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_getOptions(
    apache::thrift::ContextStack* ctx,
    ::std::map<::std::string, ::std::string> const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_getOptions_presult result;
  result.get<0>().value = const_cast<::std::map<::std::string, ::std::string>*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("getOptions", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_getOptions(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "getOptions");
    return;
  }
}
//
// End of Method 'getOptions'
//

//
// Method 'aliveSince'
//
template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::setUpAndProcess_aliveSince(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    apache::thrift::SerializedCompressedRequest&& serializedRequest,
    apache::thrift::Cpp2RequestContext* ctx,
    folly::EventBase* eb,
    [[maybe_unused]] apache::thrift::concurrency::ThreadManager* tm) {
  if (!setUpRequestProcessing(
          req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) {
    return;
  }
  auto scope = iface_->getRequestExecutionScope(
      ctx, apache::thrift::concurrency::IMPORTANT);
  ctx->setRequestExecutionScope(std::move(scope));
  processInThread(
      std::move(req),
      std::move(serializedRequest),
      ctx,
      eb,
      tm,
      apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE,
      &BaseServiceAsyncProcessor::
          executeRequest_aliveSince<ProtocolIn_, ProtocolOut_>,
      this);
}

template <typename ProtocolIn_, typename ProtocolOut_>
void BaseServiceAsyncProcessor::executeRequest_aliveSince(
    apache::thrift::ServerRequest&& serverRequest) {
  // make sure getRequestContext is null
  // so async calls don't accidentally use it
  iface_->setRequestContext(nullptr);
  struct ArgsState {
    BaseService_aliveSince_pargs pargs() {
      BaseService_aliveSince_pargs args;
      return args;
    }

    auto asTupleOfRefs() & {
      return std::tie(
      );
    }
  } args;

  auto ctxStack = apache::thrift::ContextStack::create(
      this->getEventHandlersSharedPtr(),
      this->getServiceName(),
      "BaseService.aliveSince",
      serverRequest.requestContext());
  try {
    auto pargs = args.pargs();
    deserializeRequest<ProtocolIn_>(
        pargs,
        "aliveSince",
        apache::thrift::detail::ServerRequestHelper::compressedRequest(
            std::move(serverRequest))
            .uncompress(),
        ctxStack.get());
  } catch (...) {
    folly::exception_wrapper ew(std::current_exception());
    apache::thrift::detail::ap::process_handle_exn_deserialization<
        ProtocolOut_>(
        ew,
        apache::thrift::detail::ServerRequestHelper::request(std::move(serverRequest)),
            serverRequest.requestContext(),
        apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
        "aliveSince");
    return;
  }
  auto requestPileNotification =
      apache::thrift::detail::ServerRequestHelper::moveRequestPileNotification(
          serverRequest);
  auto concurrencyControllerNotification =
      apache::thrift::detail::ServerRequestHelper::moveConcurrencyControllerNotification(
          serverRequest);
  apache::thrift::HandlerCallbackBase::MethodNameInfo methodNameInfo{
      /* .serviceName =*/ this->getServiceName(),
      /* .definingServiceName =*/ "BaseService",
      /* .methodName =*/ "aliveSince",
      /* .qualifiedMethodName =*/ "BaseService.aliveSince"};
  auto callback =
      apache::thrift::HandlerCallbackPtr<::std::int64_t>::make(
          apache::thrift::detail::ServerRequestHelper::request(
              std::move(serverRequest)),
          std::move(ctxStack),
          std::move(methodNameInfo),
          return_aliveSince<ProtocolIn_, ProtocolOut_>,
          throw_wrapped_aliveSince<ProtocolIn_, ProtocolOut_>,
          serverRequest.requestContext()->getProtoSeqId(),
          apache::thrift::detail::ServerRequestHelper::eventBase(serverRequest),
          apache::thrift::detail::ServerRequestHelper::executor(serverRequest),
          serverRequest.requestContext(),
          requestPileNotification,
          concurrencyControllerNotification,
          std::move(serverRequest.requestData()));
  const auto makeExecuteHandler = [&] {
    return [ifacePtr = iface_](auto&& cb, ArgsState args) mutable {
      (void)args;
      ifacePtr->async_tm_aliveSince(std::move(cb));
    };
  };
#if FOLLY_HAS_COROUTINES
  if (apache::thrift::detail::shouldProcessServiceInterceptorsOnRequest(
          *callback)) {
    [](auto callback, auto executeHandler, ArgsState args)
        -> folly::coro::Task<void> {
      auto argRefs = args.asTupleOfRefs();
      co_await apache::thrift::detail::processServiceInterceptorsOnRequest(
          *callback,
          apache::thrift::detail::ServiceInterceptorOnRequestArguments(
              argRefs));
      executeHandler(std::move(callback), std::move(args));
    }(std::move(callback), makeExecuteHandler(), std::move(args))
               .scheduleOn(
                   apache::thrift::detail::ServerRequestHelper::executor(
                       serverRequest))
               .startInlineUnsafe();
  } else {
    makeExecuteHandler()(std::move(callback), std::move(args));
  }
#else
  makeExecuteHandler()(std::move(callback), std::move(args));
#endif // FOLLY_HAS_COROUTINES
}

template <class ProtocolIn_, class ProtocolOut_>
apache::thrift::SerializedResponse BaseServiceAsyncProcessor::return_aliveSince(
    apache::thrift::ContextStack* ctx,
    ::std::int64_t const& _return) {
  ProtocolOut_ prot;
  ::facebook::fb303::cpp2::BaseService_aliveSince_presult result;
  result.get<0>().value = const_cast<::std::int64_t*>(&_return);
  result.setIsSet(0, true);
  return serializeResponse("aliveSince", &prot, ctx, result);
}

template <class ProtocolIn_, class ProtocolOut_>
void BaseServiceAsyncProcessor::throw_wrapped_aliveSince(
    apache::thrift::ResponseChannelRequest::UniquePtr req,
    [[maybe_unused]] int32_t protoSeqId,
    apache::thrift::ContextStack* ctx,
    folly::exception_wrapper ew,
    apache::thrift::Cpp2RequestContext* reqCtx) {
  if (!ew) {
    return;
  }
  {
    apache::thrift::detail::ap::process_throw_wrapped_handler_error<
        ProtocolOut_>(ew, std::move(req), reqCtx, ctx, "aliveSince");
    return;
  }
}
//
// End of Method 'aliveSince'
//

//
// End of Service Methods
//

} // namespace facebook::fb303::cpp2
