tools/fidl/fidlgen_cpp/goldens/protocol_layouts_wire_messaging.cc.golden

// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = output_index_json

#include <lib/fidl/cpp/features.h>
#if __FIDL_SUPPORT_HANDLES

#include <fidl/test.protocollayouts/cpp/wire_messaging.h>

#include <memory>

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

  namespace test_protocollayouts {

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OneWayAnonComposed_Ordinal = 467706262354916833lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest>::kPrimarySize);

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayAnonComposed_Ordinal = 1634702755099390832lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayAnonComposedWithError_Ordinal = 3374101322700362141lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OnAnonComposed_Ordinal = 9198778981238868491lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OneWayNamedComposed_Ordinal = 6735359826241449560lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportTablePayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportTablePayload>::kPrimarySize);

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayNamedComposed_Ordinal = 1110122450485917712lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportUnionPayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportUnionPayload>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayNamedComposedWithError_Ordinal = 3520341666774118271lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportTablePayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportTablePayload>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OnNamedComposed_Ordinal = 6802961197456477674lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OneWayImport_Ordinal = 374039999976906043lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayImport_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportTablePayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportTablePayload>::kPrimarySize);

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayImport_Ordinal = 3167860988423964164lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayImport_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportUnionPayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportUnionPayload>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayImportWithError_Ordinal = 4837028007581646602lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayImportWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportTablePayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportTablePayload>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OnImport_Ordinal = 6584793811321990352lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnImport_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = 6085941264859402051lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts::wire::LocalTablePayload)
        == ::fidl::TypeTraits<::test_protocollayouts::wire::LocalTablePayload>::kPrimarySize);

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = 7763901300032164763lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts::wire::LocalUnionPayload)
        == ::fidl::TypeTraits<::test_protocollayouts::wire::LocalUnionPayload>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = 5609487496960056151lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocalWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts::wire::LocalTablePayload)
        == ::fidl::TypeTraits<::test_protocollayouts::wire::LocalTablePayload>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OnLocal_Ordinal = 4199259762307646332lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = 4203317713771984620lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest)
        == ::fidl::TypeTraits<::test_protocollayouts::wire::MainProtocolOneWayAnonRequest>::kPrimarySize);

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = 7435080039097281487lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest)
        == ::fidl::TypeTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = 7770394869745610225lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest)
        == ::fidl::TypeTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest>::kPrimarySize);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kMainProtocol_OnAnon_Ordinal = 7275479350674227467lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, body) == sizeof(fidl_message_header_t));}  // namespace test_protocollayouts

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayAnonComposed>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayNamedComposed>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayImport>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayImport>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayImport>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayImport>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayImport>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayImport>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayImport>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayImport>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayImport>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImport>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayImport>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImport>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImport>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImport>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayImportWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayLocal>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayLocal>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayLocal>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayLocal>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayLocal>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayLocal>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayLocal>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayLocal>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayLocal>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayLocal>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnon>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnon>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayAnon>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnon>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayAnon>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnon>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayAnon>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnon>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::OneWayAnon>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnon>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(result) {}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(result) {}

  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed> _request_object{ ComposedProtocolOneWayAnonComposedRequest };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayNamedComposed(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed> _request_object{ ImportTablePayload };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayImport(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport> _request_object{ ImportTablePayload };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayLocal(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal> _request_object{ LocalTablePayload };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnon(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon> _request_object{ MainProtocolOneWayAnonRequest };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _request{ ImportUnionPayload };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _request{ ImportTablePayload };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayImport> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport> _request{ ImportUnionPayload };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayImport>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayImportWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImportWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _request{ ImportTablePayload };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayImportWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayLocal> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal> _request{ LocalUnionPayload };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayLocal>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocalWithError(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _request{ LocalTablePayload };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnon> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnon>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonWithError(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
    return ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed> _request{ ComposedProtocolOneWayAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayNamedComposed(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed> _request{ ImportTablePayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayImport(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayImport>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport> _request{ ImportTablePayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayLocal(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal> _request{ LocalTablePayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnon(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::OneWayAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon> _request{ MainProtocolOneWayAnonRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _request{ ImportUnionPayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _request{ ImportTablePayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayImport> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayImport>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport> _request{ ImportUnionPayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayImport>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayImportWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImportWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayImportWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _request{ ImportTablePayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayImportWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayLocal> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayLocal>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal> _request{ LocalUnionPayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayLocal>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocalWithError(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _request{ LocalTablePayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnon> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnon>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnon>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonWithError(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _request{ ImportUnionPayload };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _request{ ImportTablePayload };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport> _request{ ImportUnionPayload };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImportWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _request{ ImportTablePayload };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal> _request{ LocalUnionPayload };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocalWithError(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _request{ LocalTablePayload };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonWithError(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
          return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

::fidl::internal::WireEventDispatcher<::test_protocollayouts::MainProtocol>::WireEventDispatcher(::fidl::internal::WireEventHandlerInterface<::test_protocollayouts::MainProtocol>* event_handler)
: IncomingEventDispatcher(event_handler) {}

  ::fidl::Status fidl::WireSyncEventHandler<::test_protocollayouts::MainProtocol>::HandleOneEvent(
      ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client_end) {
      ::fidl::internal::IncomingEventsStorage<::test_protocollayouts::MainProtocol> event_storage;
      fidl::internal::WireEventDispatcher<::test_protocollayouts::MainProtocol> dispatcher{this};
      return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
  }
  ::fidl::Status
  fidl::internal::WireEventDispatcher<::test_protocollayouts::MainProtocol>::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
      case ::test_protocollayouts::kMainProtocol_OnAnonComposed_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnAnonComposed(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayouts::kMainProtocol_OnNamedComposed_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnNamedComposed(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayouts::kMainProtocol_OnImport_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnImport(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayouts::kMainProtocol_OnLocal_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnLocal(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayouts::kMainProtocol_OnAnon_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnAnon(primary);
        }
        return ::fidl::Status::Ok();
      }
      default:
        std::move(msg).CloseHandles();
        return ::fidl::Status::UnknownOrdinal();
    }
  }
void fidl::WireAsyncEventHandler<::test_protocollayouts::MainProtocol>::OnAnonComposed(::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>* event) {}
void fidl::WireAsyncEventHandler<::test_protocollayouts::MainProtocol>::OnNamedComposed(::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>* event) {}
void fidl::WireAsyncEventHandler<::test_protocollayouts::MainProtocol>::OnImport(::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnImport>* event) {}
void fidl::WireAsyncEventHandler<::test_protocollayouts::MainProtocol>::OnLocal(::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnLocal>* event) {}
void fidl::WireAsyncEventHandler<::test_protocollayouts::MainProtocol>::OnAnon(::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnAnon>* event) {}

constexpr ::fidl::internal::MethodEntry fidl::internal::WireServerDispatcher<::test_protocollayouts::MainProtocol>::entries_[] = {
    { ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->OneWayAnonComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayAnonComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayAnonComposedWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportTablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->OneWayNamedComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportUnionPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayNamedComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportTablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayNamedComposedWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_OneWayImport_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportTablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::OneWayImport>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->OneWayImport(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportUnionPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayImport>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayImport(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportTablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayImportWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_OneWayLocal_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts::wire::LocalTablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::OneWayLocal>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->OneWayLocal(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts::wire::LocalUnionPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayLocal>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayLocal(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts::wire::LocalTablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayLocalWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_OneWayAnon_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts::wire::MainProtocolOneWayAnonRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::OneWayAnon>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->OneWayAnon(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayAnon>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayAnon(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::MainProtocol>*>(interface)->TwoWayAnonWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::WireServerDispatcher<::test_protocollayouts::MainProtocol>::entries_end_ =
    &entries_[15];

::fidl::DispatchResult fidl::internal::WireServerDispatcher<::test_protocollayouts::MainProtocol>::TryDispatch(
    ::fidl::WireServer<::test_protocollayouts::MainProtocol>* impl, ::fidl::IncomingHeaderAndMessage& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  return ::fidl::internal::TryDispatch(
    impl, msg, storage_view, txn, entries_, entries_end_);
}

void fidl::internal::WireServerDispatcher<::test_protocollayouts::MainProtocol>::Dispatch(::fidl::WireServer<::test_protocollayouts::MainProtocol>* 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 fidl::WireServer<::test_protocollayouts::MainProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::WireServerDispatcher<::test_protocollayouts::MainProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}

fidl::WireServer<::test_protocollayouts::MainProtocol>::Handler fidl::WireServer<::test_protocollayouts::MainProtocol>::bind_handler(async_dispatcher_t* dispatcher) {
  return [impl=this, dispatcher=dispatcher](::fidl::ServerEnd<::test_protocollayouts::MainProtocol> request) {
      (void) ::fidl::BindServer(dispatcher, std::move(request), impl);
  };
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::Reply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  return MakeReply(ComposedProtocolTwoWayAnonComposedResponse);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _response{ ComposedProtocolTwoWayAnonComposedResponse };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::Reply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  return MakeReply(ComposedProtocolTwoWayAnonComposedResponse);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _response{ ComposedProtocolTwoWayAnonComposedResponse };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _response{ ComposedProtocolTwoWayAnonComposedWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::ReplySuccess(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
    ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse);
return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _response{ ComposedProtocolTwoWayAnonComposedWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::ReplySuccess(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
    ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse);
return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::Reply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  return MakeReply(ImportTablePayload);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::MakeReply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _response{ ImportTablePayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::Reply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  return MakeReply(ImportTablePayload);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::MakeReply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _response{ ImportTablePayload };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts_imported::wire::ImportUnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _response{ ComposedProtocolTwoWayNamedComposedWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    ::test_protocollayouts_imported::wire::ImportUnionPayload _response = std::move(ImportUnionPayload);
return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts_imported::wire::ImportUnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _response{ ComposedProtocolTwoWayNamedComposedWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    ::test_protocollayouts_imported::wire::ImportUnionPayload _response = std::move(ImportUnionPayload);
return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImport>::Reply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  return MakeReply(ImportTablePayload);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImport>::MakeReply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport> _response{ ImportTablePayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImport>::Reply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  return MakeReply(ImportTablePayload);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImport>::MakeReply(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport> _response{ ImportTablePayload };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayImport>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImport>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImport>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImport>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImport>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts_imported::wire::ImportUnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult MainProtocolTwoWayImportWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _response{ MainProtocolTwoWayImportWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    ::test_protocollayouts_imported::wire::ImportUnionPayload _response = std::move(ImportUnionPayload);
return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts_imported::wire::ImportUnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult MainProtocolTwoWayImportWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _response{ MainProtocolTwoWayImportWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayImportWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImportWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
    ::test_protocollayouts_imported::wire::ImportUnionPayload _response = std::move(ImportUnionPayload);
return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts_imported::wire::ImportUnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocal>::Reply(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
  return MakeReply(LocalTablePayload);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocal>::MakeReply(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal> _response{ LocalTablePayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocal>::Reply(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
  return MakeReply(LocalTablePayload);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocal>::MakeReply(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal> _response{ LocalTablePayload };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocal>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocal>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts::wire::LocalUnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::LocalUnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult MainProtocolTwoWayLocalWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _response{ MainProtocolTwoWayLocalWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::ReplySuccess(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
    ::test_protocollayouts::wire::LocalUnionPayload _response = std::move(LocalUnionPayload);
return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::LocalUnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts::wire::LocalUnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::LocalUnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult MainProtocolTwoWayLocalWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _response{ MainProtocolTwoWayLocalWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::ReplySuccess(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
    ::test_protocollayouts::wire::LocalUnionPayload _response = std::move(LocalUnionPayload);
return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::LocalUnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnon>::Reply(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  return MakeReply(MainProtocolTwoWayAnonResponse);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnon>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon> _response{ MainProtocolTwoWayAnonResponse };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnon>::Reply(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  return MakeReply(MainProtocolTwoWayAnonResponse);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnon>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon> _response{ MainProtocolTwoWayAnonResponse };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnon>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnon>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult MainProtocolTwoWayAnonWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _response{ MainProtocolTwoWayAnonWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::ReplySuccess(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse MainProtocolTwoWayAnonWithErrorResponse) {
    ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse _response = std::move(MainProtocolTwoWayAnonWithErrorResponse);
return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::Reply(::fit::result<uint32_t, ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult MainProtocolTwoWayAnonWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _response{ MainProtocolTwoWayAnonWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::ReplySuccess(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse MainProtocolTwoWayAnonWithErrorResponse) {
    ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse _response = std::move(MainProtocolTwoWayAnonWithErrorResponse);
return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult::WithErr(std::move(error)));
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>::TransactionalRequest(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest)
    : body(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest { ComposedProtocolOneWayAnonComposedRequest } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::TransactionalRequest(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest)
    : body(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest { ComposedProtocolTwoWayAnonComposedRequest } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::WireResponse(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) : ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse(ComposedProtocolTwoWayAnonComposedResponse){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::TransactionalResponse(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(ComposedProtocolTwoWayAnonComposedResponse)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedResponse, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::TransactionalRequest(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest)
    : body(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest { ComposedProtocolTwoWayAnonComposedWithErrorRequest } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::WireResponse(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) : ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult(ComposedProtocolTwoWayAnonComposedWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::TransactionalResponse(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(ComposedProtocolTwoWayAnonComposedWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>::TransactionalEvent(::test_protocollayouts_imported::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest)
    : body{ ComposedProtocolOnAnonComposedRequest } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OnAnonComposed_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnAnonComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OnAnonComposed_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>::TransactionalRequest(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload)
    : body(::test_protocollayouts_imported::wire::ImportTablePayload { ImportTablePayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::TransactionalRequest(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload)
    : body(::test_protocollayouts_imported::wire::ImportUnionPayload { ImportUnionPayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportUnionPayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportUnionPayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::WireResponse(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) : ::test_protocollayouts_imported::wire::ImportTablePayload(ImportTablePayload){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::TransactionalResponse(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(ImportTablePayload)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::TransactionalRequest(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload)
    : body(::test_protocollayouts_imported::wire::ImportTablePayload { ImportTablePayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::WireResponse(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) : ::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult(ComposedProtocolTwoWayNamedComposedWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::TransactionalResponse(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(ComposedProtocolTwoWayNamedComposedWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>::TransactionalEvent(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload)
    : body{ ImportUnionPayload } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OnNamedComposed_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnNamedComposed_Ordinal, ::test_protocollayouts::kMainProtocol_OnNamedComposed_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayImport_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayImport_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>::TransactionalRequest(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload)
    : body(::test_protocollayouts_imported::wire::ImportTablePayload { ImportTablePayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayImport_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayImport_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImport_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>::TransactionalRequest(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload)
    : body(::test_protocollayouts_imported::wire::ImportUnionPayload { ImportUnionPayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImport_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportUnionPayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportUnionPayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>::WireResponse(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) : ::test_protocollayouts_imported::wire::ImportTablePayload(ImportTablePayload){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>::TransactionalResponse(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>(ImportTablePayload)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImport_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImport_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImport>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::TransactionalRequest(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload)
    : body(::test_protocollayouts_imported::wire::ImportTablePayload { ImportTablePayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportTablePayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::WireResponse(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult MainProtocolTwoWayImportWithErrorResult) : ::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult(MainProtocolTwoWayImportWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::TransactionalResponse(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult MainProtocolTwoWayImportWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(MainProtocolTwoWayImportWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayImportWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>::TransactionalEvent(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload)
    : body{ ImportUnionPayload } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnImport_Ordinal, ::test_protocollayouts::kMainProtocol_OnImport_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnImport_Ordinal, ::test_protocollayouts::kMainProtocol_OnImport_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnImport>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnImport>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayLocal_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayLocal_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>::TransactionalRequest(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload)
    : body(::test_protocollayouts::wire::LocalTablePayload { LocalTablePayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayLocal_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayLocal_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts::wire::LocalTablePayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts::wire::LocalTablePayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocal_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>::TransactionalRequest(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload)
    : body(::test_protocollayouts::wire::LocalUnionPayload { LocalUnionPayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocal_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts::wire::LocalUnionPayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts::wire::LocalUnionPayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>::WireResponse(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) : ::test_protocollayouts::wire::LocalTablePayload(LocalTablePayload){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>::TransactionalResponse(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>(LocalTablePayload)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocal_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocal_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::LocalTablePayload, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::LocalTablePayload, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocal>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::TransactionalRequest(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload)
    : body(::test_protocollayouts::wire::LocalTablePayload { LocalTablePayload } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts::wire::LocalTablePayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts::wire::LocalTablePayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::WireResponse(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult MainProtocolTwoWayLocalWithErrorResult) : ::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult(MainProtocolTwoWayLocalWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::TransactionalResponse(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult MainProtocolTwoWayLocalWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(MainProtocolTwoWayLocalWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>::TransactionalEvent(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload)
    : body{ LocalUnionPayload } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnLocal_Ordinal, ::test_protocollayouts::kMainProtocol_OnLocal_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnLocal_Ordinal, ::test_protocollayouts::kMainProtocol_OnLocal_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnLocal>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnLocal>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayAnon_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayAnon_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>::TransactionalRequest(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest)
    : body(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest { MainProtocolOneWayAnonRequest } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OneWayAnon_Ordinal, ::test_protocollayouts::kMainProtocol_OneWayAnon_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts::wire::MainProtocolOneWayAnonRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts::wire::MainProtocolOneWayAnonRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnon_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>::TransactionalRequest(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest)
    : body(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest { MainProtocolTwoWayAnonRequest } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnon_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>::WireResponse(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) : ::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse(MainProtocolTwoWayAnonResponse){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>::TransactionalResponse(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>(MainProtocolTwoWayAnonResponse)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnon_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnon_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnon>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::TransactionalRequest(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest)
    : body(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest { MainProtocolTwoWayAnonWithErrorRequest } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::WireResponse(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult MainProtocolTwoWayAnonWithErrorResult) : ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult(MainProtocolTwoWayAnonWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::TransactionalResponse(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult MainProtocolTwoWayAnonWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(MainProtocolTwoWayAnonWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>::TransactionalEvent(::test_protocollayouts::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest)
    : body{ MainProtocolOnAnonRequest } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnAnon_Ordinal, ::test_protocollayouts::kMainProtocol_OnAnon_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kMainProtocol_OnAnon_Ordinal, ::test_protocollayouts::kMainProtocol_OnAnon_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnAnon>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::MainProtocol::OnAnon>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::WireCodingConstraintEmpty, false>;

      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed> _request{ ComposedProtocolOneWayAnonComposedRequest };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnonComposed> _request{ ComposedProtocolOneWayAnonComposedRequest };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayouts_imported::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::OneWayNamedComposed(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed> _request{ ImportTablePayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayNamedComposed(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayNamedComposed> _request{ ImportTablePayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _request{ ImportUnionPayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> _request{ ImportUnionPayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _request{ ImportTablePayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> _request{ ImportTablePayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::OneWayImport(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport> _request{ ImportTablePayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayImport>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayImport(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayImport> _request{ ImportTablePayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayImport>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport> _request{ ImportUnionPayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImport> _request{ ImportUnionPayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImportWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _request{ ImportTablePayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayImportWithError(::test_protocollayouts_imported::wire::ImportTablePayload ImportTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayImportWithError> _request{ ImportTablePayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::OneWayLocal(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal> _request{ LocalTablePayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayLocal>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayLocal(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayLocal> _request{ LocalTablePayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayLocal>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal> _request{ LocalUnionPayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocal> _request{ LocalUnionPayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocalWithError(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _request{ LocalTablePayload };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayLocalWithError(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> _request{ LocalTablePayload };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnon(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon> _request{ MainProtocolOneWayAnonRequest };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnon>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnon(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::OneWayAnon> _request{ MainProtocolOneWayAnonRequest };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnon>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonWithError(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
        return ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::MainProtocol>::TwoWayAnonWithError(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
        return ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed(::test_protocollayouts_imported::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed> _response{ImportUnionPayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed> _response{ImportUnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed> _response{ImportUnionPayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed> _response{ImportUnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport> _response{ImportUnionPayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnImport>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport> _response{ImportUnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport> _response{ImportUnionPayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnImport(::test_protocollayouts_imported::wire::ImportUnionPayload ImportUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnImport>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport> _response{ImportUnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnImport>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal> _response{LocalUnionPayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal> _response{LocalUnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal> _response{LocalUnionPayload };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnLocal(::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal> _response{LocalUnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnAnon(::test_protocollayouts::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnon(::test_protocollayouts::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnAnon(::test_protocollayouts::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnon(::test_protocollayouts::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::MainProtocol::OnAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

  namespace test_protocollayouts {

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_FlexibleOneWay_Ordinal = 3516779973873009953lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest, value) == 0);

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_FlexibleTwoWayNoError_Ordinal = 5572735551219638488lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleTwoWayNoError_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest, value) == 0);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_FlexibleTwoWayWithError_Ordinal = 3504132377779779458lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleTwoWayWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest, value) == 0);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_FlexibleEvent_Ordinal = 9152311661656086484lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_StrictOneWay_Ordinal = 8790149921168801703lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest, value) == 0);

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_StrictTwoWayNoError_Ordinal = 3690935745864999300lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictTwoWayNoError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest, value) == 0);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>>::kPrimarySize);
          static_assert(offsetof(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, value) == 0);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_StrictTwoWayWithError_Ordinal = 5364624536440098871lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictTwoWayWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest, value) == 0);
      static_assert(sizeof(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>)
          == ::fidl::TypeTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>>::kPrimarySize);
      static_assert(sizeof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>)
          == ::fidl::TypeTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>>::kPrimarySize);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_StrictEvent_Ordinal = 3921073878922106269lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
    static_assert(sizeof(::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>)
      == ::fidl::TypeTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, body) == sizeof(fidl_message_header_t));

  [[maybe_unused]]
  constexpr uint64_t kOpenProtocol_FlexibleOneWayNamedPayload_Ordinal = 1525606789639046512lu;

  [[maybe_unused]]
  constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleOneWayNamedPayload_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
    static_assert(sizeof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>)
        == ::fidl::TypeTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>>::kPrimarySize);
    static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, header) == 0);
      static_assert(offsetof(::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, body) == sizeof(fidl_message_header_t));

    static_assert(sizeof(::test_protocollayouts_imported::wire::ImportStructPayload)
        == ::fidl::TypeTraits<::test_protocollayouts_imported::wire::ImportStructPayload>::kPrimarySize);
          static_assert(offsetof(::test_protocollayouts_imported::wire::ImportStructPayload, value) == 0);}  // namespace test_protocollayouts

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleOneWay>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>(result) {}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(result) {}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(result) {}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictOneWay>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictOneWay>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictOneWay>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictOneWay>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictOneWay>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictOneWay>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictOneWay>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictOneWay>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictOneWay>(result) {}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(result) {}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
            ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::MessageDirection::kSending>();
        uint8_t* request_bytes = buffer;
        static_assert(buffer_size > request_byte_capacity);
        uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
        uint8_t* response_bytes = &buffer[request_byte_capacity];

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>> handle_storage;
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(
            outgoing.Call(
                client_end.handle(),
                handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
            )
        );
        SetStatus(::fidl::internal::StatusFromResult(decoded));
          if (ok()) {
            decoded_ = std::move(decoded.value());
            ExtractValueFromDecoded(decoded_.pointer());
          }
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireUnownedResult(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>* response)
        : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(fidl::Status::Ok()), decoded_(response) {
      ExtractValueFromDecoded(decoded_.pointer());
    }

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireUnownedResult(
        ::fit::result<::fidl::Error, ::fidl::DecodedValue<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>>>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(::fidl::internal::StatusFromResult(decoded)) {
      if (decoded.is_ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
    }

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(result) {}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>* request
) {
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}

::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::WireResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>(result) {}

    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>* request) {
      constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>();
      ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
      if (!allocation.is_ok()) {
        SetStatus(allocation.error_value());
        return;
      }
      uint8_t* buffer = allocation->data;
        uint32_t request_byte_capacity = buffer_size;
        uint8_t* request_bytes = buffer;

      ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>> request_message(
          request_bytes, request_byte_capacity, request);
      auto& outgoing = request_message.GetOutgoingMessage();
        outgoing.Write(client_end.handle());
        SetStatus(outgoing);
    }
    ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::WireUnownedResult(
        ::fit::result<::fidl::Error>&& decoded,
        ::fidl::internal::MessageStorageViewBase* storage_view
    ) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>(::fidl::internal::StatusFromResult(decoded)) {}

  ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::WireUnownedResult(const ::fidl::Status& result) : ::fidl::BaseWireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>(result) {}

  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWay(int32_t value) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay> _request_object{ value };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::OpenProtocol>::StrictOneWay(int32_t value) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay> _request_object{ value };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWayNamedPayload(int32_t value) {
    __UNINITIALIZED
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload> _request_object{ value };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayNoError(int32_t value) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _request{ value };
    return ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayWithError(int32_t value) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _request{ value };
    return ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayNoError(int32_t value) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _request{ value };
    return ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayWithError(int32_t value) {
    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _request{ value };
    return ::fidl::internal::WireThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWay(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleOneWay>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay> _request{ value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::OpenProtocol>::StrictOneWay(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictOneWay>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay> _request{ value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWayNamedPayload(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload> _request{ value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayNoError(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _request{ value };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayWithError(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _request{ value };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayNoError(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _request{ value };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayWithError(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _request{ value };
  return ::fidl::internal::WireBufferThenable<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}

  ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayNoError(int32_t value) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _request{ value };
          return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayWithError(int32_t value) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _request{ value };
          return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayNoError(int32_t value) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _request{ value };
          return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

  ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayWithError(int32_t value) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _request{ value };
          return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

::fidl::internal::WireEventDispatcher<::test_protocollayouts::OpenProtocol>::WireEventDispatcher(::fidl::internal::WireEventHandlerInterface<::test_protocollayouts::OpenProtocol>* event_handler)
: IncomingEventDispatcher(event_handler) {}

  ::fidl::Status fidl::WireSyncEventHandler<::test_protocollayouts::OpenProtocol>::HandleOneEvent(
      ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol> client_end) {
      ::fidl::internal::IncomingEventsStorage<::test_protocollayouts::OpenProtocol> event_storage;
      fidl::internal::WireEventDispatcher<::test_protocollayouts::OpenProtocol> dispatcher{this};
      return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
  }
  ::fidl::Status
  fidl::internal::WireEventDispatcher<::test_protocollayouts::OpenProtocol>::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
      case ::test_protocollayouts::kOpenProtocol_FlexibleEvent_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->FlexibleEvent(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayouts::kOpenProtocol_StrictEvent_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->StrictEvent(primary);
        }
        return ::fidl::Status::Ok();
      }
      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_protocollayouts::OpenProtocol::kOpenness, unknown_method_type)) {
          if (event_handler()) {
            ::fidl::UnknownEventMetadata<::test_protocollayouts::OpenProtocol> metadata {
              .event_ordinal = ordinal,
            };
            event_handler()->handle_unknown_event(metadata);
          }
          return ::fidl::Status::Ok();
        }
        return ::fidl::Status::UnknownOrdinal();
    }
  }
void fidl::WireAsyncEventHandler<::test_protocollayouts::OpenProtocol>::FlexibleEvent(::fidl::WireEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>* event) {}
void fidl::WireAsyncEventHandler<::test_protocollayouts::OpenProtocol>::StrictEvent(::fidl::WireEvent<::test_protocollayouts::OpenProtocol::StrictEvent>* event) {}

constexpr ::fidl::internal::MethodEntry fidl::internal::WireServerDispatcher<::test_protocollayouts::OpenProtocol>::entries_[] = {
    { ::test_protocollayouts::kOpenProtocol_FlexibleOneWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->FlexibleOneWay(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->FlexibleTwoWayNoError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->FlexibleTwoWayWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kOpenProtocol_StrictOneWay_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::StrictOneWay>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->StrictOneWay(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->StrictTwoWayNoError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->StrictTwoWayWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayouts::kOpenProtocol_FlexibleOneWayNamedPayload_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayouts_imported::wire::ImportStructPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->FlexibleOneWayNamedPayload(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::WireServerDispatcher<::test_protocollayouts::OpenProtocol>::entries_end_ =
    &entries_[7];
const ::fidl::internal::UnknownMethodHandlerEntry fidl::internal::WireServerDispatcher<::test_protocollayouts::OpenProtocol>::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<::fidl::WireServer<::test_protocollayouts::OpenProtocol>*>(interface)->handle_unknown_method(
        ::fidl::UnknownMethodMetadata<::test_protocollayouts::OpenProtocol> {
          .method_ordinal = method_ordinal,

          .unknown_method_type = unknown_method_type,

      }, completer);
  },
  .send_reply = ::fidl::internal::SendChannelUnknownMethodReply,
};

::fidl::DispatchResult fidl::internal::WireServerDispatcher<::test_protocollayouts::OpenProtocol>::TryDispatch(
    ::fidl::WireServer<::test_protocollayouts::OpenProtocol>* impl, ::fidl::IncomingHeaderAndMessage& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  return ::fidl::internal::TryDispatch(
    impl, msg, storage_view, txn, entries_, entries_end_);
}

void fidl::internal::WireServerDispatcher<::test_protocollayouts::OpenProtocol>::Dispatch(::fidl::WireServer<::test_protocollayouts::OpenProtocol>* 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 fidl::WireServer<::test_protocollayouts::OpenProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::WireServerDispatcher<::test_protocollayouts::OpenProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}

fidl::WireServer<::test_protocollayouts::OpenProtocol>::Handler fidl::WireServer<::test_protocollayouts::OpenProtocol>::bind_handler(async_dispatcher_t* dispatcher) {
  return [impl=this, dispatcher=dispatcher](::fidl::ServerEnd<::test_protocollayouts::OpenProtocol> request) {
      (void) ::fidl::BindServer(dispatcher, std::move(request), impl);
  };
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::Reply(int32_t value) {
  ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResponse _response = ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResponse {
  .value = std::move(value),
};
return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult::WithResponse(std::move(*&_response)));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult ComposedOpenProtocolFlexibleTwoWayNoErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _response{ ComposedOpenProtocolFlexibleTwoWayNoErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::Reply(int32_t value) {
  ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResponse _response = ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResponse {
  .value = std::move(value),
};
return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult::WithResponse(std::move(*&_response)));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult ComposedOpenProtocolFlexibleTwoWayNoErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _response{ ComposedOpenProtocolFlexibleTwoWayNoErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>& fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::Reply(::fit::result<int32_t, ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult::WithResponse(std::move(*result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult ComposedOpenProtocolFlexibleTwoWayWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _response{ ComposedOpenProtocolFlexibleTwoWayWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::ReplySuccess(int32_t value) {
    ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResponse _response = ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResponse {
  .value = std::move(value),
};
return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult::WithResponse(std::move(*&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::ReplyError(int32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::Reply(::fit::result<int32_t, ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult::WithResponse(std::move(*result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult ComposedOpenProtocolFlexibleTwoWayWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _response{ ComposedOpenProtocolFlexibleTwoWayWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::ReplySuccess(int32_t value) {
    ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResponse _response = ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResponse {
  .value = std::move(value),
};
return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult::WithResponse(std::move(*&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::ReplyError(int32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::Reply(int32_t value) {
  return MakeReply(value);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::MakeReply(int32_t value) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _response{ value };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::Reply(int32_t value) {
  return MakeReply(value);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::MakeReply(int32_t value) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _response{ value };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>& fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::Reply(::fit::result<int32_t, ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult::WithResponse(std::move(*result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult ComposedOpenProtocolStrictTwoWayWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _response{ ComposedOpenProtocolStrictTwoWayWithErrorResult };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::ReplySuccess(int32_t value) {
    ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResponse _response = ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResponse {
  .value = std::move(value),
};
return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult::WithResponse(std::move(*&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::ReplyError(int32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult::WithErr(std::move(error)));
  }

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::Reply(::fit::result<int32_t, ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult::WithResponse(std::move(*result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult ComposedOpenProtocolStrictTwoWayWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _response{ ComposedOpenProtocolStrictTwoWayWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireCompleterBase(::fidl::Transaction* transaction, bool owned, bool expects_reply)
: CompleterBase(transaction, owned, expects_reply),
  WireCompleterImpl(this) {}
fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireCompleterBase(WireCompleterBase&& other) noexcept
    : CompleterBase(std::move(other)), WireCompleterImpl(this) {}

::fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>& fidl::internal::WireCompleterBase<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::operator=(WireCompleterBase&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  WireCompleterImpl::_set_core(this);
  return *this;
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::ReplySuccess(int32_t value) {
    ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResponse _response = ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResponse {
  .value = std::move(value),
};
return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult::WithResponse(std::move(*&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::ReplyError(int32_t error) {
    return MakeReply(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult::WithErr(std::move(error)));
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleOneWay_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleOneWay_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleOneWay_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleOneWay_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleOneWayRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::WireResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult ComposedOpenProtocolFlexibleTwoWayNoErrorResult) : ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult(ComposedOpenProtocolFlexibleTwoWayNoErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::TransactionalResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult ComposedOpenProtocolFlexibleTwoWayNoErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(ComposedOpenProtocolFlexibleTwoWayNoErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayNoError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayNoErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::WireResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult ComposedOpenProtocolFlexibleTwoWayWithErrorResult) : ::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult(ComposedOpenProtocolFlexibleTwoWayWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::TransactionalResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult ComposedOpenProtocolFlexibleTwoWayWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(ComposedOpenProtocolFlexibleTwoWayWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleTwoWayWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolFlexibleTwoWayWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>::TransactionalEvent(int32_t value)
    : body{ value } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleEvent_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleEvent_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleEvent_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleEvent_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictOneWay_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictOneWay_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictOneWay_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictOneWay_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictOneWayRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorResponse base) : ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorResponse(std::move(base)) {}
    ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::WireResponse(int32_t value) : ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorResponse{ .value = std::move(value)}{}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::TransactionalResponse(int32_t value)
    : body(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(value)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayNoError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorResponse, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayNoErrorResponse, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorRequest, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::WireResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult ComposedOpenProtocolStrictTwoWayWithErrorResult) : ::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult(ComposedOpenProtocolStrictTwoWayWithErrorResult){}

    ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::TransactionalResponse(::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult ComposedOpenProtocolStrictTwoWayWithErrorResult)
    : body(::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(ComposedOpenProtocolStrictTwoWayWithErrorResult)) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_DynamicFlags);
    }
  ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>::TransactionalResponse() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictTwoWayWithError_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
      encoder, value, position, recursion_depth);
  }
  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    fidl::internal::WireCodingTraits<::test_protocollayouts_imported::wire::ComposedOpenProtocolStrictTwoWayWithErrorResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
      decoder, position, recursion_depth);
  }
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template
  struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalResponse<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>, ::fidl::internal::WireCodingConstraintEmpty, false>;

    ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>::TransactionalEvent(int32_t value)
    : body{ value } {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictEvent_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictEvent_DynamicFlags);
    }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>::TransactionalEvent() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_StrictEvent_Ordinal, ::test_protocollayouts::kOpenProtocol_StrictEvent_DynamicFlags);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(
    internal::WireEncoder* encoder, ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::fidl::WireEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::WireCodingConstraintEmpty, false>;

  ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::TransactionalRequest() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleOneWayNamedPayload_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleOneWayNamedPayload_DynamicFlags);
  }

    ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>::TransactionalRequest(int32_t value)
    : body(::test_protocollayouts_imported::wire::ImportStructPayload { value } ) {
      ::fidl::InitTxnHeader(&header, 0, ::test_protocollayouts::kOpenProtocol_FlexibleOneWayNamedPayload_Ordinal, ::test_protocollayouts::kOpenProtocol_FlexibleOneWayNamedPayload_DynamicFlags);
    }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(internal::WireEncoder* encoder,
      ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    *position.As<fidl_message_header_t>() = value->header;
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportStructPayload, WireCodingConstraintEmpty, IsRecursive>::Encode(
        encoder, &value->body, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template <bool IsRecursive>
  void ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode(
    internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) {
    WireCodingTraits<::test_protocollayouts_imported::wire::ImportStructPayload, WireCodingConstraintEmpty, IsRecursive>::Decode(
        decoder, position + sizeof(fidl_message_header_t), recursion_depth);
  }

  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, ::fidl::internal::WireCodingConstraintEmpty, true>;
  template struct ::fidl::internal::WireCodingTraits<::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>, ::fidl::internal::WireCodingConstraintEmpty, false>;

      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWay(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWay(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWay> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWay>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayNoError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayNoError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayNoError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayWithError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleTwoWayWithError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleTwoWayWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictOneWay(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictOneWay>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::StrictOneWay(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictOneWay> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictOneWay>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayNoError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayNoError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayNoError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayWithError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::StrictTwoWayWithError(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::StrictTwoWayWithError>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }
      ::fidl::OneWayStatus
      fidl::internal::WireSyncClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWayNamedPayload(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload> _request{ value };
        return ::fidl::WireResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), &_request);
      }

      ::fidl::OneWayStatus
      fidl::internal::WireSyncBufferClientImpl<::test_protocollayouts::OpenProtocol>::FlexibleOneWayNamedPayload(int32_t value) {
        ::fidl::internal::TransactionalRequest<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload> _request{ value };
        return ::fidl::WireUnownedResult<::test_protocollayouts::OpenProtocol::FlexibleOneWayNamedPayload>(
          ::fidl::UnownedClientEnd<::test_protocollayouts::OpenProtocol>(_transport().get<::fidl::internal::ChannelTransport>()), _allocator(), &_request);
      }

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::OpenProtocol>::FlexibleEvent(int32_t value) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent> _response{value };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::OpenProtocol>::FlexibleEvent(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleEvent>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent> _response{value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::OpenProtocol>::FlexibleEvent(int32_t value) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent> _response{value };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::OpenProtocol>::FlexibleEvent(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::FlexibleEvent>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent> _response{value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::FlexibleEvent>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayouts::OpenProtocol>::StrictEvent(int32_t value) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent> _response{value };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayouts::OpenProtocol>::StrictEvent(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictEvent>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent> _response{value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayouts::OpenProtocol>::StrictEvent(int32_t value) {
  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent> _response{value };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayouts::OpenProtocol>::StrictEvent(int32_t value) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayouts::OpenProtocol::StrictEvent>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent> _response{value };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayouts::OpenProtocol::StrictEvent>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

#pragma clang diagnostic pop

#endif  // __FIDL_SUPPORT_HANDLES