#include <lib/fidl_driver/cpp/unknown_interactions.h>

#include <fidl/test.unknowninteractions/cpp/driver/natural_messaging.h>

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"


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_StrictTwoWayFields_Ordinal = 6841797014773573215lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictTwoWayUnion_Ordinal = 1451514501977162287lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictTwoWayTable_Ordinal = 3330693085881435529lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_StrictTwoWayTable_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_StrictTwoWayFieldsErr_Ordinal = 225387363174180470lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Ordinal = 3066880266580913088lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Ordinal = 708169949929096689lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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_FlexibleTwoWayFields_Ordinal = 8423663794424433896lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Ordinal = 8216450897182897849lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Ordinal = 1049265954148894210lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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;


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Ordinal = 6033174601748665003lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Ordinal = 6235121653537390575lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Ordinal = 940887795361350656lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
#ifdef __Fuchsia__
}  // namespace test_unknowninteractions

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWay() const {
  fdf::Arena _arena('FIDL');

  ::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::StrictTwoWayFields>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayFields() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFields>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFields_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::StrictTwoWayUnion>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayUnion() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnion>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnion_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::StrictTwoWayTable>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayTable() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTable>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTable_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 {
  fdf::Arena _arena('FIDL');

  ::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::StrictTwoWayFieldsErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayFieldsErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFieldsErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::StrictTwoWayUnionErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayUnionErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnionErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::StrictTwoWayTableErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::StrictTwoWayTableErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTableErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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 {
  fdf::Arena _arena('FIDL');

  ::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::FlexibleTwoWayFields>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayFields() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFields>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::FlexibleTwoWayUnion>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayUnion() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnion>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::FlexibleTwoWayTable>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayTable() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTable>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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 {
  fdf::Arena _arena('FIDL');

  ::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);
      });
}


::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFieldsErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayFieldsErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFieldsErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::FlexibleTwoWayUnionErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayUnionErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnionErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::FlexibleTwoWayTableErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::FlexibleTwoWayTableErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTableErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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);
      });
}


::fit::result<::fidl::OneWayError>
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 };

  fdf::Arena _arena('FIDL');

  ::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::OneWayStatus status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}


::fit::result<::fidl::OneWayError>
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 };

  fdf::Arena _arena('FIDL');

  ::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::OneWayStatus status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}
namespace test_unknowninteractions {

#endif  // __Fuchsia__
}  // namespace test_unknowninteractions

#ifdef __Fuchsia__


  ::fidl::Status
  fidl::internal::NaturalEventDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
      default:
        auto* hdr = msg.header();
        ::fidl::UnknownMethodType unknown_method_type =
            ::fidl::internal::UnknownMethodTypeFromHeader(hdr);
        bool is_flexible_interaction = ::fidl::IsFlexibleInteraction(hdr);
        auto ordinal = hdr->ordinal;
        std::move(msg).CloseHandles();
        if (is_flexible_interaction &&
            ::fidl::internal::CanHandleEvent(::test_unknowninteractions::UnknownInteractionsDriverProtocol::kOpenness, unknown_method_type)) {
          if (event_handler()) {
            ::fidl::UnknownEventMetadata<::test_unknowninteractions::UnknownInteractionsDriverProtocol> metadata {
              .event_ordinal = ordinal,
            };
            event_handler()->handle_unknown_event(metadata);
          }
          return ::fidl::Status::Ok();
        }
        return ::fidl::Status::UnknownOrdinal();
    }
  }

#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 };

  fdf::Arena _arena('FIDL');
  ::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::StrictTwoWayFields>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFields>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFields_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFields>::IntoDomainObject(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::StrictTwoWayUnion>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnion>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnion_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnion>::IntoDomainObject(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::StrictTwoWayTable>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTable>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTable_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTable>::IntoDomainObject(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::StrictTwoWayErr>::Reply(const ::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 };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>::IntoDomainObject(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::StrictTwoWayFieldsErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFieldsErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFieldsErr>::IntoDomainObject(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::StrictTwoWayUnionErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnionErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnionErr>::IntoDomainObject(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::StrictTwoWayTableErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTableErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTableErr>::IntoDomainObject(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::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(::test_unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayResult::WithResponse({}));
  ::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::FlexibleTwoWayFields>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFields>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFields_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFields>::IntoDomainObject(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::FlexibleTwoWayUnion>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnion>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnion>::IntoDomainObject(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::FlexibleTwoWayTable>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTable>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTable>::IntoDomainObject(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(const ::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 };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>::IntoDomainObject(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::FlexibleTwoWayFieldsErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFieldsErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFieldsErr>::IntoDomainObject(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::FlexibleTwoWayUnionErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnionErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnionErr>::IntoDomainObject(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::FlexibleTwoWayTableErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTableErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTableErr>::IntoDomainObject(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::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictOneWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictOneWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleOneWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleOneWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleOneWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFields_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFields>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayFields(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnion_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnion>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayUnion(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTable_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTable>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayTable(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayFieldsErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayFieldsErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayUnionErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayUnionErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::StrictTwoWayTableErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->StrictTwoWayTableErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFields>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayFields(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnion>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayUnion(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTable>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayTable(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayFieldsErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayFieldsErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayUnionErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayUnionErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsDriverProtocol::FlexibleTwoWayTableErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->FlexibleTwoWayTableErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::entries_end_ =
    &entries_[18];
const ::fidl::internal::UnknownMethodHandlerEntry fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::unknown_method_handler_entry_ = {
  .openness = ::fidl::internal::Openness::kOpen,
  .dispatch = [](void* interface, uint64_t method_ordinal,
      ::fidl::UnknownMethodType unknown_method_type, ::fidl::Transaction* txn) {
    ::fidl::UnknownMethodCompleter::Sync completer(txn);
    static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>*>(interface)->handle_unknown_method(
        ::fidl::UnknownMethodMetadata<::test_unknowninteractions::UnknownInteractionsDriverProtocol> {
          .method_ordinal = method_ordinal,
          
          .unknown_method_type = unknown_method_type,
          
      }, completer);
  },
  .send_reply = ::fidl::internal::SendDriverUnknownMethodReply,
};


void fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::Dispatch(::fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_, &unknown_method_handler_entry_);
}

void fdf::Server<::test_unknowninteractions::UnknownInteractionsDriverProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& 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 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_StrictTwoWayFields_Ordinal = 902155904889801604lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnion_Ordinal = 8952307689721713673lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_Ordinal = 3114064683372134045lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_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;


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Ordinal = 6490530264582540031lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Ordinal = 2319476129312263555lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Ordinal = 6883106306697493305lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
#ifdef __Fuchsia__
}  // namespace test_unknowninteractions

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWay() const {
  fdf::Arena _arena('FIDL');

  ::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::StrictTwoWayFields>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayFields() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFields>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFields_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::StrictTwoWayUnion>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayUnion() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnion>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnion_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::StrictTwoWayTable>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayTable() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTable>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_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 {
  fdf::Arena _arena('FIDL');

  ::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);
      });
}


::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFieldsErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayFieldsErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFieldsErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::StrictTwoWayUnionErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayUnionErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnionErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::StrictTwoWayTableErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::StrictTwoWayTableErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTableErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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);
      });
}


::fit::result<::fidl::OneWayError>
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 };

  fdf::Arena _arena('FIDL');

  ::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::OneWayStatus status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}


::fit::result<::fidl::OneWayError>
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 };

  fdf::Arena _arena('FIDL');

  ::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::OneWayStatus status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}
namespace test_unknowninteractions {

#endif  // __Fuchsia__
}  // namespace test_unknowninteractions

#ifdef __Fuchsia__


  ::fidl::Status
  fidl::internal::NaturalEventDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
      default:
        auto* hdr = msg.header();
        ::fidl::UnknownMethodType unknown_method_type =
            ::fidl::internal::UnknownMethodTypeFromHeader(hdr);
        bool is_flexible_interaction = ::fidl::IsFlexibleInteraction(hdr);
        auto ordinal = hdr->ordinal;
        std::move(msg).CloseHandles();
        if (is_flexible_interaction &&
            ::fidl::internal::CanHandleEvent(::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::kOpenness, unknown_method_type)) {
          if (event_handler()) {
            ::fidl::UnknownEventMetadata<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol> metadata {
              .event_ordinal = ordinal,
            };
            event_handler()->handle_unknown_event(metadata);
          }
          return ::fidl::Status::Ok();
        }
        return ::fidl::Status::UnknownOrdinal();
    }
  }

#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 };

  fdf::Arena _arena('FIDL');
  ::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::StrictTwoWayFields>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFields>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFields_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFields>::IntoDomainObject(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::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnion>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnion>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnion_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnion>::IntoDomainObject(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::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTable>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTable>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTable>::IntoDomainObject(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::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>::Reply(const ::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 };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>::IntoDomainObject(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::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFieldsErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFieldsErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFieldsErr>::IntoDomainObject(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::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnionErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnionErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnionErr>::IntoDomainObject(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::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTableErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTableErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTableErr>::IntoDomainObject(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::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictOneWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictOneWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_FlexibleOneWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::FlexibleOneWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->FlexibleOneWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFields_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFields>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayFields(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnion_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnion>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayUnion(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTable_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTable>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayTable(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayFieldsErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayFieldsErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayUnionErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayUnionErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol::StrictTwoWayTableErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->StrictTwoWayTableErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::entries_end_ =
    &entries_[10];
const ::fidl::internal::UnknownMethodHandlerEntry fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::unknown_method_handler_entry_ = {
  .openness = ::fidl::internal::Openness::kAjar,
  .dispatch = [](void* interface, uint64_t method_ordinal,
      ::fidl::UnknownMethodType unknown_method_type, ::fidl::Transaction* txn) {
    ::fidl::UnknownMethodCompleter::Sync completer(txn);
    static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>*>(interface)->handle_unknown_method(
        ::fidl::UnknownMethodMetadata<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol> {
          .method_ordinal = method_ordinal,
          
      }, completer);
  },
  .send_reply = ::fidl::internal::SendDriverUnknownMethodReply,
};


void fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::Dispatch(::fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_, &unknown_method_handler_entry_);
}

void fdf::Server<::test_unknowninteractions::UnknownInteractionsAjarDriverProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& 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__

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_StrictTwoWayFields_Ordinal = 5761316743698652038lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnion_Ordinal = 7235351480214368636lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_Ordinal = 1839495150551777151lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_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;


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Ordinal = 3933117456632607830lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Ordinal = 4598950031783776653lu;


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


[[maybe_unused]]
constexpr inline uint64_t kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Ordinal = 1456858375973362525lu;


[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
#ifdef __Fuchsia__
}  // namespace test_unknowninteractions

::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWay() const {
  fdf::Arena _arena('FIDL');

  ::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::StrictTwoWayFields>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayFields() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFields>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFields_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::StrictTwoWayUnion>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayUnion() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnion>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnion_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::StrictTwoWayTable>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayTable() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTable>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_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 {
  fdf::Arena _arena('FIDL');

  ::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);
      });
}


::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFieldsErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayFieldsErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFieldsErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::StrictTwoWayUnionErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayUnionErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnionErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::StrictTwoWayTableErr>
fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::StrictTwoWayTableErr() const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTableErr>(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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);
      });
}


::fit::result<::fidl::OneWayError>
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 };

  fdf::Arena _arena('FIDL');

  ::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::OneWayStatus 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 };

  fdf::Arena _arena('FIDL');
  ::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::StrictTwoWayFields>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFields>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFields_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFields_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFields>::IntoDomainObject(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::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnion>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnion>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnion_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnion_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnion>::IntoDomainObject(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::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTable>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTable>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTable>::IntoDomainObject(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::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>::Reply(const ::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 };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>::IntoDomainObject(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::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFieldsErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFieldsErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFieldsErr>::IntoDomainObject(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::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnionErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnionErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnionErr>::IntoDomainObject(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::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTableErr>::Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTableErr>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Ordinal, ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_DynamicFlags };

  fdf::Arena _arena('FIDL');
  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get());
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTableErr>::IntoDomainObject(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::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictOneWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictOneWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWay>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWay(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFields_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFields>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayFields(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnion_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnion>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayUnion(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTable_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTable>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayTable(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayFieldsErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayFieldsErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayUnionErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayUnionErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
    { ::test_unknowninteractions::kUnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
            msg, metadata);
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol::StrictTwoWayTableErr>::Sync completer(txn);
        static_cast<::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>*>(interface)->StrictTwoWayTableErr(
            
            completer);
        return ::fidl::Status::Ok();
      },
    },
};

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


void fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::Dispatch(::fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_, &unknown_method_handler_entry_);
}

void fdf::Server<::test_unknowninteractions::UnknownInteractionsClosedDriverProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& 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__


#pragma clang diagnostic pop