tools/fidl/fidlgen_llcpp/goldens/unknown_interactions_driver_natural_messaging.cc.golden

#include <fidl/test.unknowninteractions/cpp/driver/natural_messaging.h>
namespace test_unknowninteractions {
[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictOneWay_Ordinal = 6982839851953080288lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleOneWay_Ordinal = 1083620022582160398lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictTwoWay_Ordinal = 1481114722667499972lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictTwoWayErr_Ordinal = 8222960355260037542lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal = 2929398860738426482lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_FlexibleTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Ordinal = 5583489590753947170lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
#ifdef __Fuchsia__
}  // namespace test_unknowninteractions
::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWay() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayErr() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWay() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayErr() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fitx::result<::fidl::Error>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictOneWay() const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictOneWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictOneWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::ToFitxResult(
        ::fidl::Status::TransportError(_arena.status_value(), ::fdf::internal::kFailedToCreateDriverArena));
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  ::fidl::Status status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}

::fitx::result<::fidl::Error>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleOneWay() const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleOneWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleOneWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::ToFitxResult(
        ::fidl::Status::TransportError(_arena.status_value(), ::fdf::internal::kFailedToCreateDriverArena));
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  ::fidl::Status status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}
namespace test_unknowninteractions {
#endif  // __Fuchsia__
}  // namespace test_unknowninteractions
#ifdef __Fuchsia__

#endif  // __Fuchsia__

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>::Reply() {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>::Reply(::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>&& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  _encoder.EncodeBody(
      ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>::Reply(::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>&& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  _encoder.EncodeBody(
      ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>::Reply(::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>&& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  _encoder.EncodeBody(
      ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}
#ifdef __Fuchsia__

constexpr ::fidl::internal::MethodEntry fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::entries_[] = {
    {
        ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictOneWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictOneWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictOneWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictOneWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleOneWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleOneWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleOneWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleOneWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayErr(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayErr(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::entries_end_ =
    &entries_[6];

void fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::Dispatch(::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>* impl, ::fidl::IncomingMessage&& msg,
                                                                                                                      internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_);
}
void fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::dispatch_message(
    ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}
#endif  // __Fuchsia__

namespace test_unknowninteractions {
[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictOneWay_Ordinal = 9111839835597799810lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsClosedDriverProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_Ordinal = 2815690661228737027lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Ordinal = 4350840352076287137lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
#ifdef __Fuchsia__
}  // namespace test_unknowninteractions
::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWay() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayErr() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fitx::result<::fidl::Error>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictOneWay() const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictOneWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictOneWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::ToFitxResult(
        ::fidl::Status::TransportError(_arena.status_value(), ::fdf::internal::kFailedToCreateDriverArena));
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  ::fidl::Status status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}
namespace test_unknowninteractions {
#endif  // __Fuchsia__
}  // namespace test_unknowninteractions
#ifdef __Fuchsia__

#endif  // __Fuchsia__

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>::Reply() {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>::Reply(::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>&& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  _encoder.EncodeBody(
      ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}
#ifdef __Fuchsia__

constexpr ::fidl::internal::MethodEntry fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::entries_[] = {
    {
        ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictOneWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictOneWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictOneWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictOneWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayErr(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::entries_end_ =
    &entries_[3];

void fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::Dispatch(::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>* impl, ::fidl::IncomingMessage&& msg,
                                                                                                                            internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_);
}
void fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::dispatch_message(
    ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}
#endif  // __Fuchsia__

namespace test_unknowninteractions {
[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictOneWay_Ordinal = 200845620698173917lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsAjarDriverProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_FlexibleOneWay_Ordinal = 3790953144423004126lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsAjarDriverProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_Ordinal = 523076268125513549lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]] constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Ordinal = 7057260423103547829lu;

[[maybe_unused]] constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
#ifdef __Fuchsia__
}  // namespace test_unknowninteractions
::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWay() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayErr() const {
  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>(
        &client_base(), {}, &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_DynamicFlags,
        [](NaturalMessageEncoder& encoder) {},
        [status = _arena.status_value()](
            ::fidl::internal::ThenableBase* base,
            ::fidl::internal::NaturalMessageEncoder&,
            ::fidl::internal::ResponseContext* response_context) {
          ::fidl::OutgoingMessage msg{
              ::fidl::Status::TransportError(status, ::fdf::internal::kFailedToCreateDriverArena)};
          base->SendTwoWay(msg, response_context);
        });
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
      },
      [arena = std::move(*_arena)](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

::fitx::result<::fidl::Error>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictOneWay() const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictOneWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictOneWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::ToFitxResult(
        ::fidl::Status::TransportError(_arena.status_value(), ::fdf::internal::kFailedToCreateDriverArena));
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  ::fidl::Status status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}

::fitx::result<::fidl::Error>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::FlexibleOneWay() const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_FlexibleOneWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_FlexibleOneWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    return ::fidl::internal::ToFitxResult(
        ::fidl::Status::TransportError(_arena.status_value(), ::fdf::internal::kFailedToCreateDriverArena));
  }

  ::fidl::WriteOptions _options = {
      .outgoing_transport_context =
          ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get()),
  };
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  ::fidl::Status status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}
namespace test_unknowninteractions {
#endif  // __Fuchsia__
}  // namespace test_unknowninteractions
#ifdef __Fuchsia__

#endif  // __Fuchsia__

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>::Reply() {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}

void fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>::Reply(::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>&& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_DynamicFlags};

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  _encoder.EncodeBody(
      ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}
#ifdef __Fuchsia__

constexpr ::fidl::internal::MethodEntry fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::entries_[] = {
    {
        ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictOneWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictOneWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictOneWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictOneWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_FlexibleOneWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::FlexibleOneWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::FlexibleOneWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->FlexibleOneWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWay(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Ordinal,
        [](void* interface, ::fidl::IncomingMessage&& msg,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fitx::result decoded = ::fidl::internal::DecodeTransactionalMessage(std::move(msg));
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::Request<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr> request;
          ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>::Sync completer(txn);
          static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayErr(
              request, completer);
          return ::fidl::Status::Ok();
        },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::entries_end_ =
    &entries_[4];

void fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::Dispatch(::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>* impl, ::fidl::IncomingMessage&& msg,
                                                                                                                          internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_);
}
void fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::dispatch_message(
    ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}
#endif  // __Fuchsia__