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

#pragma once

#include <lib/fidl/internal.h>
#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.h>
#include <lib/fidl/llcpp/envelope.h>
#include <lib/fidl/llcpp/errors.h>
#include <lib/fidl/llcpp/message.h>
#include <lib/fidl/llcpp/message_storage.h>
#include <lib/fidl/llcpp/object_view.h>
#include <lib/fidl/llcpp/string_view.h>
#include <lib/fidl/llcpp/traits.h>
#include <lib/fidl/llcpp/vector_view.h>
#include <lib/fit/function.h>
#include <lib/stdcompat/optional.h>

#include <algorithm>
#include <cstddef>
#include <variant>
#ifdef __Fuchsia__
#include <lib/fidl/llcpp/client.h>
#include <lib/fidl/llcpp/client_end.h>
#include <lib/fidl/llcpp/connect_service.h>
#include <lib/fidl/llcpp/result.h>
#include <lib/fidl/llcpp/server.h>
#include <lib/fidl/llcpp/server_end.h>
#include <lib/fidl/llcpp/service_handler_interface.h>
#include <lib/fidl/llcpp/sync_call.h>
#include <lib/fidl/llcpp/transaction.h>
#include <lib/fidl/llcpp/wire_messaging.h>
#include <lib/fidl/txn_header.h>
#include <lib/zx/channel.h>
#include <lib/zx/handle.h>
#include <lib/zx/socket.h>

#endif  // __Fuchsia__
#include <zircon/fidl.h>

namespace fidl_test_protocols {
namespace wire {

enum class obj_type : uint32_t {

  NONE = 0u,

  SOCKET = 14u,
};

struct WithErrorSyntax_ResponseAsStruct_Response;

class WithErrorSyntax_ResponseAsStruct_Result;

struct WithErrorSyntax_ErrorAsPrimitive_Response;

class WithErrorSyntax_ErrorAsPrimitive_Result;

struct WithErrorSyntax_ErrorAsEnum_Response;
}  // namespace wire
class DiscoverableProtocol;

class Transitional;

class ChannelProtocol;

class WithAndWithoutRequestResponse;
namespace wire {

enum class ErrorEnun : uint32_t {

  ERR_FOO = 1u,

  ERR_BAR = 2u,
};

class WithErrorSyntax_ErrorAsEnum_Result;
}  // namespace wire
class WithErrorSyntax;
namespace wire {

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntax_ResponseAsStruct_ResultTable;

class WithErrorSyntax_ResponseAsStruct_Result {
 public:
  WithErrorSyntax_ResponseAsStruct_Result()
      : ordinal_(::fidl_test_protocols::wire::
                     WithErrorSyntax_ResponseAsStruct_Result::Ordinal::Invalid),
        envelope_{} {}

  WithErrorSyntax_ResponseAsStruct_Result(
      const WithErrorSyntax_ResponseAsStruct_Result&) = default;
  WithErrorSyntax_ResponseAsStruct_Result& operator=(
      const WithErrorSyntax_ResponseAsStruct_Result&) = default;
  WithErrorSyntax_ResponseAsStruct_Result(
      WithErrorSyntax_ResponseAsStruct_Result&&) = default;
  WithErrorSyntax_ResponseAsStruct_Result& operator=(
      WithErrorSyntax_ResponseAsStruct_Result&&) = default;

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  bool has_invalid_tag() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::
               WithErrorSyntax_ResponseAsStruct_Result::Ordinal::Invalid;
  }

  bool is_response() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::
               WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kResponse;
  }

  static WithErrorSyntax_ResponseAsStruct_Result WithResponse(
      ::fidl::ObjectView<::fidl_test_protocols::wire::
                             WithErrorSyntax_ResponseAsStruct_Response>
          val) {
    WithErrorSyntax_ResponseAsStruct_Result result;
    result.set_response(val);
    return result;
  }

  template <typename... Args>
  static WithErrorSyntax_ResponseAsStruct_Result WithResponse(
      ::fidl::AnyAllocator& allocator, Args&&... args) {
    WithErrorSyntax_ResponseAsStruct_Result result;
    result.set_response(
        ::fidl::ObjectView<::fidl_test_protocols::wire::
                               WithErrorSyntax_ResponseAsStruct_Response>(
            allocator, std::forward<Args>(args)...));
    return result;
  }

  void set_response(
      ::fidl::ObjectView<::fidl_test_protocols::wire::
                             WithErrorSyntax_ResponseAsStruct_Response>
          elem) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kResponse;
    envelope_.data =
        ::fidl::ObjectView<void>::FromExternal(static_cast<void*>(elem.get()));
  }

  template <typename... Args>
  void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kResponse;
    set_response(
        ::fidl::ObjectView<::fidl_test_protocols::wire::
                               WithErrorSyntax_ResponseAsStruct_Response>(
            allocator, std::forward<Args>(args)...));
  }

  ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response&
  mutable_response() {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kResponse);
    return *static_cast<::fidl_test_protocols::wire::
                            WithErrorSyntax_ResponseAsStruct_Response*>(
        envelope_.data.get());
  }
  const ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response&
  response() const {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kResponse);
    return *static_cast<::fidl_test_protocols::wire::
                            WithErrorSyntax_ResponseAsStruct_Response*>(
        envelope_.data.get());
  }

  bool is_err() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::
               WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kErr;
  }

  static WithErrorSyntax_ResponseAsStruct_Result WithErr(
      ::fidl::ObjectView<uint32_t> val) {
    WithErrorSyntax_ResponseAsStruct_Result result;
    result.set_err(val);
    return result;
  }

  template <typename... Args>
  static WithErrorSyntax_ResponseAsStruct_Result WithErr(
      ::fidl::AnyAllocator& allocator, Args&&... args) {
    WithErrorSyntax_ResponseAsStruct_Result result;
    result.set_err(
        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
    return result;
  }

  void set_err(::fidl::ObjectView<uint32_t> elem) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kErr;
    envelope_.data =
        ::fidl::ObjectView<void>::FromExternal(static_cast<void*>(elem.get()));
  }

  template <typename... Args>
  void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kErr;
    set_err(
        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
  }

  uint32_t& mutable_err() {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kErr);
    return *static_cast<uint32_t*>(envelope_.data.get());
  }
  const uint32_t& err() const {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ResponseAsStruct_Result::Ordinal::kErr);
    return *static_cast<uint32_t*>(envelope_.data.get());
  }
  ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result::Tag
  which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<::fidl_test_protocols::wire::
                           WithErrorSyntax_ResponseAsStruct_Result::Tag>(
        ordinal_);
  }

  static constexpr const fidl_type_t* Type =
      &fidl_test_protocols_WithErrorSyntax_ResponseAsStruct_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 24;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  static void SizeAndOffsetAssertionHelper();
  ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result::Ordinal
      ordinal_;
  FIDL_ALIGNDECL
  ::fidl::Envelope<void> envelope_;
};

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntax_ErrorAsPrimitive_ResultTable;

class WithErrorSyntax_ErrorAsPrimitive_Result {
 public:
  WithErrorSyntax_ErrorAsPrimitive_Result()
      : ordinal_(::fidl_test_protocols::wire::
                     WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::Invalid),
        envelope_{} {}

  WithErrorSyntax_ErrorAsPrimitive_Result(
      const WithErrorSyntax_ErrorAsPrimitive_Result&) = default;
  WithErrorSyntax_ErrorAsPrimitive_Result& operator=(
      const WithErrorSyntax_ErrorAsPrimitive_Result&) = default;
  WithErrorSyntax_ErrorAsPrimitive_Result(
      WithErrorSyntax_ErrorAsPrimitive_Result&&) = default;
  WithErrorSyntax_ErrorAsPrimitive_Result& operator=(
      WithErrorSyntax_ErrorAsPrimitive_Result&&) = default;

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  bool has_invalid_tag() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::
               WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::Invalid;
  }

  bool is_response() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::
               WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kResponse;
  }

  static WithErrorSyntax_ErrorAsPrimitive_Result WithResponse(
      ::fidl::ObjectView<::fidl_test_protocols::wire::
                             WithErrorSyntax_ErrorAsPrimitive_Response>
          val) {
    WithErrorSyntax_ErrorAsPrimitive_Result result;
    result.set_response(val);
    return result;
  }

  template <typename... Args>
  static WithErrorSyntax_ErrorAsPrimitive_Result WithResponse(
      ::fidl::AnyAllocator& allocator, Args&&... args) {
    WithErrorSyntax_ErrorAsPrimitive_Result result;
    result.set_response(
        ::fidl::ObjectView<::fidl_test_protocols::wire::
                               WithErrorSyntax_ErrorAsPrimitive_Response>(
            allocator, std::forward<Args>(args)...));
    return result;
  }

  void set_response(
      ::fidl::ObjectView<::fidl_test_protocols::wire::
                             WithErrorSyntax_ErrorAsPrimitive_Response>
          elem) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kResponse;
    envelope_.data =
        ::fidl::ObjectView<void>::FromExternal(static_cast<void*>(elem.get()));
  }

  template <typename... Args>
  void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kResponse;
    set_response(
        ::fidl::ObjectView<::fidl_test_protocols::wire::
                               WithErrorSyntax_ErrorAsPrimitive_Response>(
            allocator, std::forward<Args>(args)...));
  }

  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Response&
  mutable_response() {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kResponse);
    return *static_cast<::fidl_test_protocols::wire::
                            WithErrorSyntax_ErrorAsPrimitive_Response*>(
        envelope_.data.get());
  }
  const ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Response&
  response() const {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kResponse);
    return *static_cast<::fidl_test_protocols::wire::
                            WithErrorSyntax_ErrorAsPrimitive_Response*>(
        envelope_.data.get());
  }

  bool is_err() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::
               WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kErr;
  }

  static WithErrorSyntax_ErrorAsPrimitive_Result WithErr(
      ::fidl::ObjectView<uint32_t> val) {
    WithErrorSyntax_ErrorAsPrimitive_Result result;
    result.set_err(val);
    return result;
  }

  template <typename... Args>
  static WithErrorSyntax_ErrorAsPrimitive_Result WithErr(
      ::fidl::AnyAllocator& allocator, Args&&... args) {
    WithErrorSyntax_ErrorAsPrimitive_Result result;
    result.set_err(
        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
    return result;
  }

  void set_err(::fidl::ObjectView<uint32_t> elem) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kErr;
    envelope_.data =
        ::fidl::ObjectView<void>::FromExternal(static_cast<void*>(elem.get()));
  }

  template <typename... Args>
  void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
    ordinal_ = ::fidl_test_protocols::wire::
        WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kErr;
    set_err(
        ::fidl::ObjectView<uint32_t>(allocator, std::forward<Args>(args)...));
  }

  uint32_t& mutable_err() {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kErr);
    return *static_cast<uint32_t*>(envelope_.data.get());
  }
  const uint32_t& err() const {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal::kErr);
    return *static_cast<uint32_t*>(envelope_.data.get());
  }
  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result::Tag
  which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<::fidl_test_protocols::wire::
                           WithErrorSyntax_ErrorAsPrimitive_Result::Tag>(
        ordinal_);
  }

  static constexpr const fidl_type_t* Type =
      &fidl_test_protocols_WithErrorSyntax_ErrorAsPrimitive_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  static void SizeAndOffsetAssertionHelper();
  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result::Ordinal
      ordinal_;
  FIDL_ALIGNDECL
  ::fidl::Envelope<void> envelope_;
};

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntax_ErrorAsEnum_ResultTable;

class WithErrorSyntax_ErrorAsEnum_Result {
 public:
  WithErrorSyntax_ErrorAsEnum_Result()
      : ordinal_(::fidl_test_protocols::wire::
                     WithErrorSyntax_ErrorAsEnum_Result::Ordinal::Invalid),
        envelope_{} {}

  WithErrorSyntax_ErrorAsEnum_Result(
      const WithErrorSyntax_ErrorAsEnum_Result&) = default;
  WithErrorSyntax_ErrorAsEnum_Result& operator=(
      const WithErrorSyntax_ErrorAsEnum_Result&) = default;
  WithErrorSyntax_ErrorAsEnum_Result(WithErrorSyntax_ErrorAsEnum_Result&&) =
      default;
  WithErrorSyntax_ErrorAsEnum_Result& operator=(
      WithErrorSyntax_ErrorAsEnum_Result&&) = default;

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  bool has_invalid_tag() const {
    return ordinal_ == ::fidl_test_protocols::wire::
                           WithErrorSyntax_ErrorAsEnum_Result::Ordinal::Invalid;
  }

  bool is_response() const {
    return ordinal_ ==
           ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
               Ordinal::kResponse;
  }

  static WithErrorSyntax_ErrorAsEnum_Result WithResponse(
      ::fidl::ObjectView<
          ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>
          val) {
    WithErrorSyntax_ErrorAsEnum_Result result;
    result.set_response(val);
    return result;
  }

  template <typename... Args>
  static WithErrorSyntax_ErrorAsEnum_Result WithResponse(
      ::fidl::AnyAllocator& allocator, Args&&... args) {
    WithErrorSyntax_ErrorAsEnum_Result result;
    result.set_response(
        ::fidl::ObjectView<
            ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>(
            allocator, std::forward<Args>(args)...));
    return result;
  }

  void set_response(
      ::fidl::ObjectView<
          ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>
          elem) {
    ordinal_ = ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
        Ordinal::kResponse;
    envelope_.data =
        ::fidl::ObjectView<void>::FromExternal(static_cast<void*>(elem.get()));
  }

  template <typename... Args>
  void set_response(::fidl::AnyAllocator& allocator, Args&&... args) {
    ordinal_ = ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
        Ordinal::kResponse;
    set_response(
        ::fidl::ObjectView<
            ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>(
            allocator, std::forward<Args>(args)...));
  }

  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response&
  mutable_response() {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
                  Ordinal::kResponse);
    return *static_cast<
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response*>(
        envelope_.data.get());
  }
  const ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response&
  response() const {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
                  Ordinal::kResponse);
    return *static_cast<
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response*>(
        envelope_.data.get());
  }

  bool is_err() const {
    return ordinal_ == ::fidl_test_protocols::wire::
                           WithErrorSyntax_ErrorAsEnum_Result::Ordinal::kErr;
  }

  static WithErrorSyntax_ErrorAsEnum_Result WithErr(
      ::fidl::ObjectView<::fidl_test_protocols::wire::ErrorEnun> val) {
    WithErrorSyntax_ErrorAsEnum_Result result;
    result.set_err(val);
    return result;
  }

  template <typename... Args>
  static WithErrorSyntax_ErrorAsEnum_Result WithErr(
      ::fidl::AnyAllocator& allocator, Args&&... args) {
    WithErrorSyntax_ErrorAsEnum_Result result;
    result.set_err(::fidl::ObjectView<::fidl_test_protocols::wire::ErrorEnun>(
        allocator, std::forward<Args>(args)...));
    return result;
  }

  void set_err(
      ::fidl::ObjectView<::fidl_test_protocols::wire::ErrorEnun> elem) {
    ordinal_ = ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
        Ordinal::kErr;
    envelope_.data =
        ::fidl::ObjectView<void>::FromExternal(static_cast<void*>(elem.get()));
  }

  template <typename... Args>
  void set_err(::fidl::AnyAllocator& allocator, Args&&... args) {
    ordinal_ = ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
        Ordinal::kErr;
    set_err(::fidl::ObjectView<::fidl_test_protocols::wire::ErrorEnun>(
        allocator, std::forward<Args>(args)...));
  }

  ::fidl_test_protocols::wire::ErrorEnun& mutable_err() {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
                  Ordinal::kErr);
    return *static_cast<::fidl_test_protocols::wire::ErrorEnun*>(
        envelope_.data.get());
  }
  const ::fidl_test_protocols::wire::ErrorEnun& err() const {
    ZX_ASSERT(ordinal_ ==
              ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::
                  Ordinal::kErr);
    return *static_cast<::fidl_test_protocols::wire::ErrorEnun*>(
        envelope_.data.get());
  }
  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::Tag which()
      const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::Tag>(
        ordinal_);
  }

  static constexpr const fidl_type_t* Type =
      &fidl_test_protocols_WithErrorSyntax_ErrorAsEnum_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
  };

  static void SizeAndOffsetAssertionHelper();
  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result::Ordinal
      ordinal_;
  FIDL_ALIGNDECL
  ::fidl::Envelope<void> envelope_;
};

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntax_ResponseAsStruct_ResponseTable;

struct WithErrorSyntax_ResponseAsStruct_Response {
  static constexpr const fidl_type_t* Type =
      &fidl_test_protocols_WithErrorSyntax_ResponseAsStruct_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  int64_t a = {};

  int64_t b = {};

  int64_t c = {};

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WithErrorSyntax_ResponseAsStruct_Response* value)
        : message_(bytes, byte_size,
                   sizeof(WithErrorSyntax_ResponseAsStruct_Response), nullptr,
                   0, 0) {
      message_.Encode<WithErrorSyntax_ResponseAsStruct_Response>(value);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }

   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(
        WithErrorSyntax_ResponseAsStruct_Response* value)
        : message_(bytes_.data(), bytes_.size(), value) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }

   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<struct WithErrorSyntax_ResponseAsStruct_Response>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<struct WithErrorSyntax_ResponseAsStruct_Response>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    struct WithErrorSyntax_ResponseAsStruct_Response* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<
          struct WithErrorSyntax_ResponseAsStruct_Response*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };
};

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntax_ErrorAsPrimitive_ResponseTable;

struct WithErrorSyntax_ErrorAsPrimitive_Response {
  static constexpr const fidl_type_t* Type =
      &fidl_test_protocols_WithErrorSyntax_ErrorAsPrimitive_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WithErrorSyntax_ErrorAsPrimitive_Response* value)
        : message_(bytes, byte_size,
                   sizeof(WithErrorSyntax_ErrorAsPrimitive_Response), nullptr,
                   0, 0) {
      message_.Encode<WithErrorSyntax_ErrorAsPrimitive_Response>(value);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }

   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(
        WithErrorSyntax_ErrorAsPrimitive_Response* value)
        : message_(bytes_.data(), bytes_.size(), value) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }

   private:
    ::fidl::internal::InlineMessageBuffer<8> bytes_;
    UnownedEncodedMessage message_;
  };

  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<struct WithErrorSyntax_ErrorAsPrimitive_Response>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<struct WithErrorSyntax_ErrorAsPrimitive_Response>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    struct WithErrorSyntax_ErrorAsPrimitive_Response* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<
          struct WithErrorSyntax_ErrorAsPrimitive_Response*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };
};

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntax_ErrorAsEnum_ResponseTable;

struct WithErrorSyntax_ErrorAsEnum_Response {
  static constexpr const fidl_type_t* Type =
      &fidl_test_protocols_WithErrorSyntax_ErrorAsEnum_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WithErrorSyntax_ErrorAsEnum_Response* value)
        : message_(bytes, byte_size,
                   sizeof(WithErrorSyntax_ErrorAsEnum_Response), nullptr, 0,
                   0) {
      message_.Encode<WithErrorSyntax_ErrorAsEnum_Response>(value);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }

   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(WithErrorSyntax_ErrorAsEnum_Response* value)
        : message_(bytes_.data(), bytes_.size(), value) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }

   private:
    ::fidl::internal::InlineMessageBuffer<8> bytes_;
    UnownedEncodedMessage message_;
  };

  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<struct WithErrorSyntax_ErrorAsEnum_Response>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<struct WithErrorSyntax_ErrorAsEnum_Response>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    struct WithErrorSyntax_ErrorAsEnum_Response* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<struct WithErrorSyntax_ErrorAsEnum_Response*>(
          bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };
};

}  // namespace wire
extern "C" const fidl_type_t
    fidl_test_protocols_DiscoverableProtocolMethodRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_DiscoverableProtocolMethodResponseTable;

class DiscoverableProtocol final {
  DiscoverableProtocol() = delete;

 public:
  class Method final {
    Method() = delete;
  };
};
}  // namespace fidl_test_protocols
#ifdef __Fuchsia__

template <>
struct ::fidl::internal::ProtocolDetails<
    ::fidl_test_protocols::DiscoverableProtocol> {
  static constexpr char DiscoverableName[] =
      "fidl.test.protocols.DiscoverableProtocol";
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::WireDispatcher<
    ::fidl_test_protocols::DiscoverableProtocol>
    final {
  WireDispatcher() = delete;
  static ::fidl::DispatchResult TryDispatch(
      ::fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
  static ::fidl::DispatchResult Dispatch(
      ::fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
};
#endif  // __Fuchsia__

template <>
struct ::fidl::WireRequest<::fidl_test_protocols::DiscoverableProtocol::Method>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::DiscoverableProtocol::Method>
    final : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
          _client);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

 private:
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::DiscoverableProtocol::Method>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
          _client);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;
};

// Methods to make a sync FIDL call directly on an unowned channel or a
// const reference to a
// |fidl::ClientEnd<::fidl_test_protocols::DiscoverableProtocol>|, avoiding
// setting up a client.
template <>
class ::fidl::internal::WireCaller<::fidl_test_protocols::DiscoverableProtocol>
    final {
 public:
  explicit WireCaller(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
          client_end)
      : client_end_(client_end) {}

  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::DiscoverableProtocol::Method>
  Method(::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
             _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::DiscoverableProtocol::Method>(_client_end);
  }
  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::DiscoverableProtocol::Method>
  Method() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::DiscoverableProtocol::Method>(client_end_);
  }

 private:
  ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
      client_end_;
};
#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireEventHandlerInterface<
    ::fidl_test_protocols::DiscoverableProtocol> {
 public:
  WireEventHandlerInterface() = default;
  virtual ~WireEventHandlerInterface() = default;
};

template <>
class ::fidl::WireAsyncEventHandler<::fidl_test_protocols::DiscoverableProtocol>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::DiscoverableProtocol> {
 public:
  WireAsyncEventHandler() = default;

  virtual void Unbound(::fidl::UnbindInfo info) {}
};

template <>
class ::fidl::WireSyncEventHandler<::fidl_test_protocols::DiscoverableProtocol>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::DiscoverableProtocol> {
 public:
  WireSyncEventHandler() = default;

  // Method called when an unknown event is found. This methods gives the status
  // which, in this case, is returned by HandleOneEvent.
  virtual zx_status_t Unknown() = 0;

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method.
  ::fidl::Result HandleOneEvent(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
          client_end);
};
#endif  // __Fuchsia__

template <>
class ::fidl::WireSyncClient<::fidl_test_protocols::DiscoverableProtocol>
    final {
 public:
  WireSyncClient() = default;

  explicit WireSyncClient(
      ::fidl::ClientEnd<::fidl_test_protocols::DiscoverableProtocol> client_end)
      : client_end_(std::move(client_end)) {}

  ~WireSyncClient() = default;
  WireSyncClient(WireSyncClient&&) = default;
  WireSyncClient& operator=(WireSyncClient&&) = default;

  const ::fidl::ClientEnd<::fidl_test_protocols::DiscoverableProtocol>&
  client_end() const {
    return client_end_;
  }
  ::fidl::ClientEnd<::fidl_test_protocols::DiscoverableProtocol>& client_end() {
    return client_end_;
  }

  const ::zx::channel& channel() const { return client_end_.channel(); }
  ::zx::channel* mutable_channel() { return &client_end_.channel(); }

  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::DiscoverableProtocol::Method>
  Method() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::DiscoverableProtocol::Method>(
        this->client_end());
  }

 private:
  ::fidl::ClientEnd<::fidl_test_protocols::DiscoverableProtocol> client_end_;
};

// Pure-virtual interface to be implemented by a server.
// This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>|
// and |fidl::ServerEnd<SomeProtocol>|).
template <>
class ::fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>
    : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  WireInterface() = default;
  virtual ~WireInterface() = default;

  // The marker protocol type within which this |WireInterface| class is
  // defined.
  using _EnclosingProtocol = ::fidl_test_protocols::DiscoverableProtocol;

  using MethodCompleter = ::fidl::Completer<>;

  virtual void Method(MethodCompleter::Sync& _completer) = 0;

 private:
  ::fidl::DispatchResult dispatch_message(fidl_incoming_msg_t* msg,
                                          ::fidl::Transaction* txn) final;
};

namespace fidl_test_protocols {
extern "C" const fidl_type_t
    fidl_test_protocols_TransitionalRequestRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_TransitionalRequestResponseTable;

extern "C" const fidl_type_t fidl_test_protocols_TransitionalOneWayRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_TransitionalOneWayResponseTable;

extern "C" const fidl_type_t fidl_test_protocols_TransitionalEventRequestTable;

extern "C" const fidl_type_t fidl_test_protocols_TransitionalEventEventTable;

class Transitional final {
  Transitional() = delete;

 public:
  class Request final {
    Request() = delete;
  };
  class OneWay final {
    OneWay() = delete;
  };
  class Event final {
    Event() = delete;
  };
};
}  // namespace fidl_test_protocols
#ifdef __Fuchsia__

template <>
struct ::fidl::internal::ProtocolDetails<::fidl_test_protocols::Transitional> {
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::WireDispatcher<::fidl_test_protocols::Transitional>
    final {
  WireDispatcher() = delete;
  static ::fidl::DispatchResult TryDispatch(
      ::fidl::WireInterface<::fidl_test_protocols::Transitional>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
  static ::fidl::DispatchResult Dispatch(
      ::fidl::WireInterface<::fidl_test_protocols::Transitional>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
};
#endif  // __Fuchsia__

template <>
struct ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request> final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t x;
  explicit WireRequest(zx_txid_t _txid, int64_t x) : x(x) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_TransitionalRequestRequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 24;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType =
      ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          int64_t x)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, x);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, int64_t x)
        : message_(bytes_.data(), bytes_.size(), _txid, x) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t y;
  explicit WireResponse(int64_t y) : y(y) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_TransitionalRequestResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, int64_t y)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{y};
      message_.Encode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>(
          &_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>(
          response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(int64_t y)
        : message_(bytes_.data(), bytes_.size(), y) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
            response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*>(
          bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay> final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t x;
  explicit WireRequest(zx_txid_t _txid, int64_t x) : x(x) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_TransitionalOneWayRequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 24;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          int64_t x)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, x);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, int64_t x)
        : message_(bytes_.data(), bytes_.size(), _txid, x) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event> final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t x;
  explicit WireResponse(int64_t x) : x(x) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::fidl_test_protocols_TransitionalEventEventTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, int64_t x)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{x};
      message_.Encode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>(
          &_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>(
          response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(int64_t x)
        : message_(bytes_.data(), bytes_.size(), x) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>*
            response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>*>(
          bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::Transitional::Request> final
    : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
      int64_t x);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
      int64_t x, zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>* Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*>(
        bytes_.data());
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::Transitional::Request>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>& value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<24> bytes_;
};
template <>
class ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t x,
      uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>* Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*>(
        bytes_);
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::Transitional::Request>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>& value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay> final
    : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
      int64_t x);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

 private:
};
template <>
class ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::OneWay>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t x);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;
};

// Methods to make a sync FIDL call directly on an unowned channel or a
// const reference to a |fidl::ClientEnd<::fidl_test_protocols::Transitional>|,
// avoiding setting up a client.
template <>
class ::fidl::internal::WireCaller<::fidl_test_protocols::Transitional> final {
 public:
  explicit WireCaller(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> client_end)
      : client_end_(client_end) {}

  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::Transitional::Request>
  Request(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client_end,
      int64_t x) {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::Request>(
        _client_end, x);
  }
  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::Transitional::Request> Request(
      int64_t x) && {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::Request>(
        client_end_, x);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request>
  Request(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client_end,
      ::fidl::BufferSpan _request_buffer, int64_t x,
      ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::Request>(
        _client_end, _request_buffer.data, _request_buffer.capacity, x,
        _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request>
  Request(::fidl::BufferSpan _request_buffer, int64_t x,
          ::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::Request>(
        client_end_, _request_buffer.data, _request_buffer.capacity, x,
        _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 24 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay> OneWay(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client_end,
      int64_t x) {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay>(
        _client_end, x);
  }
  // Allocates 24 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay> OneWay(
      int64_t x) && {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay>(
        client_end_, x);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::OneWay>
  OneWay(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client_end,
      ::fidl::BufferSpan _request_buffer, int64_t x) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::OneWay>(
        _client_end, _request_buffer.data, _request_buffer.capacity, x);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::OneWay> OneWay(
      ::fidl::BufferSpan _request_buffer, int64_t x) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::OneWay>(
        client_end_, _request_buffer.data, _request_buffer.capacity, x);
  }

 private:
  ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> client_end_;
};
#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireEventHandlerInterface<
    ::fidl_test_protocols::Transitional> {
 public:
  WireEventHandlerInterface() = default;
  virtual ~WireEventHandlerInterface() = default;
  virtual void Event(
      ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>* event) {
  }
};

template <>
class ::fidl::WireAsyncEventHandler<::fidl_test_protocols::Transitional>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::Transitional> {
 public:
  WireAsyncEventHandler() = default;

  virtual void Unbound(::fidl::UnbindInfo info) {}
};

template <>
class ::fidl::WireSyncEventHandler<::fidl_test_protocols::Transitional>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::Transitional> {
 public:
  WireSyncEventHandler() = default;

  // Method called when an unknown event is found. This methods gives the status
  // which, in this case, is returned by HandleOneEvent.
  virtual zx_status_t Unknown() = 0;

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method.
  ::fidl::Result HandleOneEvent(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> client_end);
};
#endif  // __Fuchsia__

template <>
class ::fidl::WireSyncClient<::fidl_test_protocols::Transitional> final {
 public:
  WireSyncClient() = default;

  explicit WireSyncClient(
      ::fidl::ClientEnd<::fidl_test_protocols::Transitional> client_end)
      : client_end_(std::move(client_end)) {}

  ~WireSyncClient() = default;
  WireSyncClient(WireSyncClient&&) = default;
  WireSyncClient& operator=(WireSyncClient&&) = default;

  const ::fidl::ClientEnd<::fidl_test_protocols::Transitional>& client_end()
      const {
    return client_end_;
  }
  ::fidl::ClientEnd<::fidl_test_protocols::Transitional>& client_end() {
    return client_end_;
  }

  const ::zx::channel& channel() const { return client_end_.channel(); }
  ::zx::channel* mutable_channel() { return &client_end_.channel(); }

  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::Transitional::Request> Request(
      int64_t x) {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::Request>(
        this->client_end(), x);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request>
  Request(::fidl::BufferSpan _request_buffer, int64_t x,
          ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::Request>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity, x,
        _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 24 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay> OneWay(
      int64_t x) {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay>(
        this->client_end(), x);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::OneWay> OneWay(
      ::fidl::BufferSpan _request_buffer, int64_t x) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::OneWay>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity, x);
  }

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method defined in |SyncEventHandler|. The return
  // status of the handler function is folded with any transport-level errors
  // and returned.
  ::fidl::Result HandleOneEvent(
      ::fidl::WireSyncEventHandler<::fidl_test_protocols::Transitional>&
          event_handler) {
    return event_handler.HandleOneEvent(client_end_);
  }

 private:
  ::fidl::ClientEnd<::fidl_test_protocols::Transitional> client_end_;
};

// Pure-virtual interface to be implemented by a server.
// This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>|
// and |fidl::ServerEnd<SomeProtocol>|).
template <>
class ::fidl::WireInterface<::fidl_test_protocols::Transitional>
    : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  WireInterface() = default;
  virtual ~WireInterface() = default;

  // The marker protocol type within which this |WireInterface| class is
  // defined.
  using _EnclosingProtocol = ::fidl_test_protocols::Transitional;

  class RequestCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(int64_t y);
    ::fidl::Result Reply(::fidl::BufferSpan _buffer, int64_t y);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using RequestCompleter = ::fidl::Completer<RequestCompleterBase>;

  virtual void Request(int64_t x, RequestCompleter::Sync& _completer) {
    _completer.Close(ZX_ERR_NOT_SUPPORTED);
  }

  using OneWayCompleter = ::fidl::Completer<>;

  virtual void OneWay(int64_t x, OneWayCompleter::Sync& _completer) {
    _completer.Close(ZX_ERR_NOT_SUPPORTED);
  }

 private:
  ::fidl::DispatchResult dispatch_message(fidl_incoming_msg_t* msg,
                                          ::fidl::Transaction* txn) final;
};

namespace fidl_test_protocols {
extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodARequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodAResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolEventARequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolEventAEventTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodBRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodBResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolTakeHandleRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolTakeHandleResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMutateSocketRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMutateSocketResponseTable;

class ChannelProtocol final {
  ChannelProtocol() = delete;

 public:
  class MethodA final {
    MethodA() = delete;
  };
  class EventA final {
    EventA() = delete;
  };
  class MethodB final {
    MethodB() = delete;
  };
  class TakeHandle final {
    TakeHandle() = delete;
  };
  class MutateSocket final {
    MutateSocket() = delete;
  };
};
}  // namespace fidl_test_protocols
#ifdef __Fuchsia__

template <>
struct ::fidl::internal::ProtocolDetails<
    ::fidl_test_protocols::ChannelProtocol> {};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::WireDispatcher<::fidl_test_protocols::ChannelProtocol>
    final {
  WireDispatcher() = delete;
  static ::fidl::DispatchResult TryDispatch(
      ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
  static ::fidl::DispatchResult Dispatch(
      ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
};
#endif  // __Fuchsia__

template <>
struct ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t a;
  int64_t b;
  explicit WireRequest(zx_txid_t _txid, int64_t a, int64_t b) : a(a), b(b) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolMethodARequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 32;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          int64_t a, int64_t b)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, a, b);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, int64_t a, int64_t b)
        : message_(bytes_.data(), bytes_.size(), _txid, a, b) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<32> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t a;
  int64_t b;
  explicit WireResponse(int64_t a, int64_t b) : a(a), b(b) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolEventAEventTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, int64_t a,
                          int64_t b)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{a, b};
      message_.Encode<
          ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>>(
          &_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<
          ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>>(
          response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(int64_t a, int64_t b)
        : message_(bytes_.data(), bytes_.size(), a, b) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>*
            response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<32> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::EventA>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::EventA>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::EventA>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t a;
  int64_t b;
  explicit WireRequest(zx_txid_t _txid, int64_t a, int64_t b) : a(a), b(b) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolMethodBRequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 32;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType =
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          int64_t a, int64_t b)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, a, b);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, int64_t a, int64_t b)
        : message_(bytes_.data(), bytes_.size(), _txid, a, b) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<32> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  int64_t result;
  explicit WireResponse(int64_t result) : result(result) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolMethodBResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, int64_t result)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{result};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(int64_t result)
        : message_(bytes_.data(), bytes_.size(), result) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
            response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::zx::handle h;
  explicit WireRequest(zx_txid_t _txid, ::zx::handle&& h) : h(std::move(h)) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolTakeHandleRequestTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 24;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  void _CloseHandles();

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          ::zx::handle&& h)
        : message_(_bytes, _byte_size, sizeof(WireRequest), handles_,
                   std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles), 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, std::move(h));
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), handles_,
                   std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles), 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    zx_handle_disposition_t
        handles_[std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles)];
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, ::zx::handle&& h)
        : message_(bytes_.data(), bytes_.size(), _txid, std::move(h)) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;
    ~DecodedMessage() {
      if (ok() && (PrimaryObject() != nullptr)) {
        PrimaryObject()->_CloseHandles();
      }
    }

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage() : message_(bytes_.data(), bytes_.size()) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::ChannelProtocol::TakeHandle>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::zx::socket a;
  explicit WireRequest(zx_txid_t _txid, ::zx::socket&& a) : a(std::move(a)) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolMutateSocketRequestTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 24;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType = ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>;
  void _CloseHandles();

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          ::zx::socket&& a)
        : message_(_bytes, _byte_size, sizeof(WireRequest), handles_,
                   std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles), 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, std::move(a));
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), handles_,
                   std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles), 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    zx_handle_disposition_t
        handles_[std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles)];
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, ::zx::socket&& a)
        : message_(bytes_.data(), bytes_.size(), _txid, std::move(a)) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;
    ~DecodedMessage() {
      if (ok() && (PrimaryObject() != nullptr)) {
        PrimaryObject()->_CloseHandles();
      }
    }

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::zx::socket b;
  explicit WireResponse(::zx::socket&& b) : b(std::move(b)) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_ChannelProtocolMutateSocketResponseTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 24;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;
  void _CloseHandles();

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size,
                          ::zx::socket&& b)
        : message_(_bytes, _byte_size, sizeof(WireResponse), handles_,
                   std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles), 0) {
      FIDL_ALIGNDECL WireResponse _response{std::move(b)};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), handles_,
                   std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles), 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    zx_handle_disposition_t
        handles_[std::min(ZX_CHANNEL_MAX_MSG_HANDLES, MaxNumHandles)];
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(::zx::socket&& b)
        : message_(bytes_.data(), bytes_.size(), std::move(b)) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::ChannelProtocol::MutateSocket>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<24> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;
    ~DecodedMessage() {
      if (ok() && (PrimaryObject() != nullptr)) {
        PrimaryObject()->_CloseHandles();
      }
    }

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA> final
    : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      int64_t a, int64_t b);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

 private:
};
template <>
class ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodA>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t a,
      int64_t b);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB> final
    : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      int64_t a, int64_t b);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      int64_t a, int64_t b, zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*>(
        bytes_.data());
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MethodB>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<24> bytes_;
};
template <>
class ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodB>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t a,
      int64_t b, uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*>(
        bytes_);
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MethodB>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
    final : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      ::zx::handle&& h);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      ::zx::handle&& h, zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<16> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::ChannelProtocol::TakeHandle>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
      ::zx::handle&& h, uint8_t* _response_bytes,
      uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>
    final : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      ::zx::socket&& a);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      ::zx::socket&& a, zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() {
    if (ok()) {
      Unwrap()->_CloseHandles();
    }
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<24> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
      ::zx::socket&& a, uint8_t* _response_bytes,
      uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() {
    if (ok()) {
      Unwrap()->_CloseHandles();
    }
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};

// Methods to make a sync FIDL call directly on an unowned channel or a
// const reference to a
// |fidl::ClientEnd<::fidl_test_protocols::ChannelProtocol>|, avoiding setting
// up a client.
template <>
class ::fidl::internal::WireCaller<::fidl_test_protocols::ChannelProtocol>
    final {
 public:
  explicit WireCaller(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
          client_end)
      : client_end_(client_end) {}

  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA>
  MethodA(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
              _client_end,
          int64_t a, int64_t b) {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA>(
        _client_end, a, b);
  }
  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA> MethodA(
      int64_t a, int64_t b) && {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA>(
        client_end_, a, b);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MethodA>
  MethodA(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
              _client_end,
          ::fidl::BufferSpan _request_buffer, int64_t a, int64_t b) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodA>(
        _client_end, _request_buffer.data, _request_buffer.capacity, a, b);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodA>
  MethodA(::fidl::BufferSpan _request_buffer, int64_t a, int64_t b) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodA>(
        client_end_, _request_buffer.data, _request_buffer.capacity, a, b);
  }

  // Allocates 56 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>
  MethodB(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
              _client_end,
          int64_t a, int64_t b) {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>(
        _client_end, a, b);
  }
  // Allocates 56 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB> MethodB(
      int64_t a, int64_t b) && {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>(
        client_end_, a, b);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MethodB>
  MethodB(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
              _client_end,
          ::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
          ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodB>(
        _client_end, _request_buffer.data, _request_buffer.capacity, a, b,
        _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodB>
  MethodB(::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
          ::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodB>(
        client_end_, _request_buffer.data, _request_buffer.capacity, a, b,
        _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 40 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                 _client_end,
             ::zx::handle&& h) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(_client_end,
                                                            std::move(h));
  }
  // Allocates 40 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle(::zx::handle&& h) && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(client_end_,
                                                            std::move(h));
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                 _client_end,
             ::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
             ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(
        _client_end, _request_buffer.data, _request_buffer.capacity,
        std::move(h), _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle(::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
             ::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(
        client_end_, _request_buffer.data, _request_buffer.capacity,
        std::move(h), _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                   _client_end,
               ::zx::socket&& a) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(_client_end,
                                                              std::move(a));
  }
  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket(::zx::socket&& a) && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(client_end_,
                                                              std::move(a));
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                   _client_end,
               ::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
               ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
        _client_end, _request_buffer.data, _request_buffer.capacity,
        std::move(a), _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket(::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
               ::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
        client_end_, _request_buffer.data, _request_buffer.capacity,
        std::move(a), _response_buffer.data, _response_buffer.capacity);
  }

 private:
  ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> client_end_;
};
#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireEventHandlerInterface<
    ::fidl_test_protocols::ChannelProtocol> {
 public:
  WireEventHandlerInterface() = default;
  virtual ~WireEventHandlerInterface() = default;
  virtual void EventA(
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>*
          event) {}
};

template <>
class ::fidl::WireAsyncEventHandler<::fidl_test_protocols::ChannelProtocol>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::ChannelProtocol> {
 public:
  WireAsyncEventHandler() = default;

  virtual void Unbound(::fidl::UnbindInfo info) {}
};

template <>
class ::fidl::WireSyncEventHandler<::fidl_test_protocols::ChannelProtocol>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::ChannelProtocol> {
 public:
  WireSyncEventHandler() = default;

  // Method called when an unknown event is found. This methods gives the status
  // which, in this case, is returned by HandleOneEvent.
  virtual zx_status_t Unknown() = 0;

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method.
  ::fidl::Result HandleOneEvent(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
          client_end);
};
#endif  // __Fuchsia__

template <>
class ::fidl::WireSyncClient<::fidl_test_protocols::ChannelProtocol> final {
 public:
  WireSyncClient() = default;

  explicit WireSyncClient(
      ::fidl::ClientEnd<::fidl_test_protocols::ChannelProtocol> client_end)
      : client_end_(std::move(client_end)) {}

  ~WireSyncClient() = default;
  WireSyncClient(WireSyncClient&&) = default;
  WireSyncClient& operator=(WireSyncClient&&) = default;

  const ::fidl::ClientEnd<::fidl_test_protocols::ChannelProtocol>& client_end()
      const {
    return client_end_;
  }
  ::fidl::ClientEnd<::fidl_test_protocols::ChannelProtocol>& client_end() {
    return client_end_;
  }

  const ::zx::channel& channel() const { return client_end_.channel(); }
  ::zx::channel* mutable_channel() { return &client_end_.channel(); }

  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA> MethodA(
      int64_t a, int64_t b) {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA>(
        this->client_end(), a, b);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodA>
  MethodA(::fidl::BufferSpan _request_buffer, int64_t a, int64_t b) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodA>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity, a,
        b);
  }

  // Allocates 56 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB> MethodB(
      int64_t a, int64_t b) {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>(
        this->client_end(), a, b);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodB>
  MethodB(::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
          ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodB>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity, a,
        b, _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 40 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle(::zx::handle&& h) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(this->client_end(),
                                                            std::move(h));
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle(::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
             ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity,
        std::move(h), _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket(::zx::socket&& a) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
        this->client_end(), std::move(a));
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket(::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
               ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity,
        std::move(a), _response_buffer.data, _response_buffer.capacity);
  }

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method defined in |SyncEventHandler|. The return
  // status of the handler function is folded with any transport-level errors
  // and returned.
  ::fidl::Result HandleOneEvent(
      ::fidl::WireSyncEventHandler<::fidl_test_protocols::ChannelProtocol>&
          event_handler) {
    return event_handler.HandleOneEvent(client_end_);
  }

 private:
  ::fidl::ClientEnd<::fidl_test_protocols::ChannelProtocol> client_end_;
};

// Pure-virtual interface to be implemented by a server.
// This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>|
// and |fidl::ServerEnd<SomeProtocol>|).
template <>
class ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>
    : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  WireInterface() = default;
  virtual ~WireInterface() = default;

  // The marker protocol type within which this |WireInterface| class is
  // defined.
  using _EnclosingProtocol = ::fidl_test_protocols::ChannelProtocol;

  using MethodACompleter = ::fidl::Completer<>;

  virtual void MethodA(int64_t a, int64_t b,
                       MethodACompleter::Sync& _completer) = 0;

  class MethodBCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(int64_t result);
    ::fidl::Result Reply(::fidl::BufferSpan _buffer, int64_t result);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using MethodBCompleter = ::fidl::Completer<MethodBCompleterBase>;

  virtual void MethodB(int64_t a, int64_t b,
                       MethodBCompleter::Sync& _completer) = 0;

  class TakeHandleCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply();

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using TakeHandleCompleter = ::fidl::Completer<TakeHandleCompleterBase>;

  virtual void TakeHandle(::zx::handle h,
                          TakeHandleCompleter::Sync& _completer) = 0;

  class MutateSocketCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(::zx::socket&& b);
    ::fidl::Result Reply(::fidl::BufferSpan _buffer, ::zx::socket&& b);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using MutateSocketCompleter = ::fidl::Completer<MutateSocketCompleterBase>;

  virtual void MutateSocket(::zx::socket a,
                            MutateSocketCompleter::Sync& _completer) = 0;

 private:
  ::fidl::DispatchResult dispatch_message(fidl_incoming_msg_t* msg,
                                          ::fidl::Transaction* txn) final;
};

namespace fidl_test_protocols {
extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestNoResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestNoResponseResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestEmptyResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestEmptyResponseResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnEmptyResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnEmptyResponseEventTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnWithResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnWithResponseEventTable;

class WithAndWithoutRequestResponse final {
  WithAndWithoutRequestResponse() = delete;

 public:
  class NoRequestNoResponse final {
    NoRequestNoResponse() = delete;
  };
  class NoRequestEmptyResponse final {
    NoRequestEmptyResponse() = delete;
  };
  class NoRequestWithResponse final {
    NoRequestWithResponse() = delete;
  };
  class WithRequestNoResponse final {
    WithRequestNoResponse() = delete;
  };
  class WithRequestEmptyResponse final {
    WithRequestEmptyResponse() = delete;
  };
  class WithRequestWithResponse final {
    WithRequestWithResponse() = delete;
  };
  class OnEmptyResponse final {
    OnEmptyResponse() = delete;
  };
  class OnWithResponse final {
    OnWithResponse() = delete;
  };
};
}  // namespace fidl_test_protocols
#ifdef __Fuchsia__

template <>
struct ::fidl::internal::ProtocolDetails<
    ::fidl_test_protocols::WithAndWithoutRequestResponse> {};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::WireDispatcher<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    final {
  WireDispatcher() = delete;
  static ::fidl::DispatchResult TryDispatch(
      ::fidl::WireInterface<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
  static ::fidl::DispatchResult Dispatch(
      ::fidl::WireInterface<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
};
#endif  // __Fuchsia__

template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestEmptyResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestEmptyResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage() : message_(bytes_.data(), bytes_.size()) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                NoRequestEmptyResponse>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType = ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl::StringView ret;
  explicit WireResponse(::fidl::StringView ret) : ret(ret) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 4294967295;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size,
                          ::fidl::StringView ret)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{ret};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(::fidl::StringView ret)
        : message_(bytes_.data(), bytes_.size(), ret) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                NoRequestWithResponse>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl::StringView arg;
  explicit WireRequest(zx_txid_t _txid, ::fidl::StringView arg) : arg(arg) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 4294967295;
  static constexpr uint32_t AltPrimarySize = 32;
  static constexpr uint32_t AltMaxOutOfLine = 4294967295;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          ::fidl::StringView arg)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, arg);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, ::fidl::StringView arg)
        : message_(bytes_.data(), bytes_.size(), _txid, arg) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestEmptyResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl::StringView arg;
  explicit WireRequest(zx_txid_t _txid, ::fidl::StringView arg) : arg(arg) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 4294967295;
  static constexpr uint32_t AltPrimarySize = 32;
  static constexpr uint32_t AltMaxOutOfLine = 4294967295;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          ::fidl::StringView arg)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, arg);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, ::fidl::StringView arg)
        : message_(bytes_.data(), bytes_.size(), _txid, arg) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestEmptyResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage() : message_(bytes_.data(), bytes_.size()) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                WithRequestEmptyResponse>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestWithResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl::StringView arg;
  explicit WireRequest(zx_txid_t _txid, ::fidl::StringView arg) : arg(arg) {
    _InitHeader(_txid);
  }
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 4294967295;
  static constexpr uint32_t AltPrimarySize = 32;
  static constexpr uint32_t AltMaxOutOfLine = 4294967295;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType = ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid,
                          ::fidl::StringView arg)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid, arg);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid, ::fidl::StringView arg)
        : message_(bytes_.data(), bytes_.size(), _txid, arg) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestWithResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl::StringView ret;
  explicit WireResponse(::fidl::StringView ret) : ret(ret) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 4294967295;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size,
                          ::fidl::StringView ret)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{ret};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(::fidl::StringView ret)
        : message_(bytes_.data(), bytes_.size(), ret) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                WithRequestWithResponse>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnEmptyResponse>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnEmptyResponse>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage() : message_(bytes_.data(), bytes_.size()) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                OnEmptyResponse>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnEmptyResponse>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnEmptyResponse>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnEmptyResponse>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::OnWithResponse>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl::StringView ret;
  explicit WireResponse(::fidl::StringView ret) : ret(ret) { _InitHeader(); }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithAndWithoutRequestResponseOnWithResponseEventTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 32;
  static constexpr uint32_t MaxOutOfLine = 4294967295;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size,
                          ::fidl::StringView ret)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{ret};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnWithResponse>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnWithResponse>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(::fidl::StringView ret)
        : message_(bytes_.data(), bytes_.size(), ret) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<::fidl_test_protocols::
                                 WithAndWithoutRequestResponse::OnWithResponse>*
            response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnWithResponse>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnWithResponse>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnWithResponse>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
class ::fidl::WireResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>
    final : public ::fidl::Result {
 public:
  explicit WireResult(::fidl::UnownedClientEnd<
                      ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

 private:
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>
    final : public ::fidl::Result {
 public:
  explicit WireResult(::fidl::UnownedClientEnd<
                      ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client);
  WireResult(::fidl::UnownedClientEnd<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse>
                 _client,
             zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<16> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestEmptyResponse>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client,
      uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
    final : public ::fidl::Result {
 public:
  explicit WireResult(::fidl::UnownedClientEnd<
                      ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client);
  WireResult(::fidl::UnownedClientEnd<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse>
                 _client,
             zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client,
      uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>
    final : public ::fidl::Result {
 public:
  explicit WireResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      ::fidl::StringView arg);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

 private:
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
      ::fidl::StringView arg);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>
    final : public ::fidl::Result {
 public:
  explicit WireResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      ::fidl::StringView arg);
  WireResult(::fidl::UnownedClientEnd<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse>
                 _client,
             ::fidl::StringView arg, zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<16> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestEmptyResponse>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
      ::fidl::StringView arg, uint8_t* _response_bytes,
      uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>
    final : public ::fidl::Result {
 public:
  explicit WireResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      ::fidl::StringView arg);
  WireResult(::fidl::UnownedClientEnd<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse>
                 _client,
             ::fidl::StringView arg, zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestWithResponse>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client,
      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
      ::fidl::StringView arg, uint8_t* _response_bytes,
      uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};

// Methods to make a sync FIDL call directly on an unowned channel or a
// const reference to a
// |fidl::ClientEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>|,
// avoiding setting up a client.
template <>
class ::fidl::internal::WireCaller<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    final {
 public:
  explicit WireCaller(::fidl::UnownedClientEnd<
                      ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          client_end)
      : client_end_(client_end) {}

  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>
  NoRequestNoResponse(::fidl::UnownedClientEnd<
                      ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestNoResponse>(_client_end);
  }
  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>
  NoRequestNoResponse() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestNoResponse>(client_end_);
  }

  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>
  NoRequestEmptyResponse(::fidl::UnownedClientEnd<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse>
                             _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>(_client_end);
  }
  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         NoRequestEmptyResponse>
  NoRequestEmptyResponse() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>(client_end_);
  }

  // Allocates 16 bytes of request buffer on the stack. Response is
  // heap-allocated.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>
  NoRequestWithResponse(::fidl::UnownedClientEnd<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse>
                            _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(_client_end);
  }
  // Allocates 16 bytes of request buffer on the stack. Response is
  // heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         NoRequestWithResponse>
  NoRequestWithResponse() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(client_end_);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>
  NoRequestWithResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(_client_end, _response_buffer.data,
                                   _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>
  NoRequestWithResponse(::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(client_end_, _response_buffer.data,
                                   _response_buffer.capacity);
  }

  // Request is heap-allocated.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestNoResponse>
  WithRequestNoResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::StringView arg) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(_client_end, arg);
  }
  // Request is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestNoResponse>
  WithRequestNoResponse(::fidl::StringView arg) && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(client_end_, arg);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestNoResponse>
  WithRequestNoResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(_client_end, _request_buffer.data,
                                   _request_buffer.capacity, arg);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestNoResponse>
  WithRequestNoResponse(::fidl::BufferSpan _request_buffer,
                        ::fidl::StringView arg) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(client_end_, _request_buffer.data,
                                   _request_buffer.capacity, arg);
  }

  // Allocates 16 bytes of response buffer on the stack. Request is
  // heap-allocated.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>
  WithRequestEmptyResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::StringView arg) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(_client_end, arg);
  }
  // Allocates 16 bytes of response buffer on the stack. Request is
  // heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestEmptyResponse>
  WithRequestEmptyResponse(::fidl::StringView arg) && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(client_end_, arg);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>
  WithRequestEmptyResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg,
      ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(
        _client_end, _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>
  WithRequestEmptyResponse(::fidl::BufferSpan _request_buffer,
                           ::fidl::StringView arg,
                           ::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(
        client_end_, _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }

  // Request is heap-allocated. Response is heap-allocated.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>
  WithRequestWithResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::StringView arg) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(_client_end, arg);
  }
  // Request is heap-allocated. Response is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestWithResponse>
  WithRequestWithResponse(::fidl::StringView arg) && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(client_end_, arg);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>
  WithRequestWithResponse(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          _client_end,
      ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg,
      ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(
        _client_end, _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>
  WithRequestWithResponse(::fidl::BufferSpan _request_buffer,
                          ::fidl::StringView arg,
                          ::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(
        client_end_, _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }

 private:
  ::fidl::UnownedClientEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>
      client_end_;
};
#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireEventHandlerInterface<
    ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  WireEventHandlerInterface() = default;
  virtual ~WireEventHandlerInterface() = default;
  virtual void OnEmptyResponse(
      ::fidl::WireResponse<::fidl_test_protocols::
                               WithAndWithoutRequestResponse::OnEmptyResponse>*
          event) {}
  virtual void OnWithResponse(
      ::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::OnWithResponse>*
          event) {}
};

template <>
class ::fidl::WireAsyncEventHandler<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  WireAsyncEventHandler() = default;

  virtual void Unbound(::fidl::UnbindInfo info) {}
};

template <>
class ::fidl::WireSyncEventHandler<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  WireSyncEventHandler() = default;

  // Method called when an unknown event is found. This methods gives the status
  // which, in this case, is returned by HandleOneEvent.
  virtual zx_status_t Unknown() = 0;

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method.
  ::fidl::Result HandleOneEvent(
      ::fidl::UnownedClientEnd<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>
          client_end);
};
#endif  // __Fuchsia__

template <>
class ::fidl::WireSyncClient<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    final {
 public:
  WireSyncClient() = default;

  explicit WireSyncClient(
      ::fidl::ClientEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>
          client_end)
      : client_end_(std::move(client_end)) {}

  ~WireSyncClient() = default;
  WireSyncClient(WireSyncClient&&) = default;
  WireSyncClient& operator=(WireSyncClient&&) = default;

  const ::fidl::ClientEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>&
  client_end() const {
    return client_end_;
  }
  ::fidl::ClientEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>&
  client_end() {
    return client_end_;
  }

  const ::zx::channel& channel() const { return client_end_.channel(); }
  ::zx::channel* mutable_channel() { return &client_end_.channel(); }

  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>
  NoRequestNoResponse() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestNoResponse>(this->client_end());
  }

  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         NoRequestEmptyResponse>
  NoRequestEmptyResponse() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>(this->client_end());
  }

  // Allocates 16 bytes of request buffer on the stack. Response is
  // heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         NoRequestWithResponse>
  NoRequestWithResponse() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(this->client_end());
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>
  NoRequestWithResponse(::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(this->client_end(), _response_buffer.data,
                                   _response_buffer.capacity);
  }

  // Request is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestNoResponse>
  WithRequestNoResponse(::fidl::StringView arg) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(this->client_end(), arg);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestNoResponse>
  WithRequestNoResponse(::fidl::BufferSpan _request_buffer,
                        ::fidl::StringView arg) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(this->client_end(), _request_buffer.data,
                                   _request_buffer.capacity, arg);
  }

  // Allocates 16 bytes of response buffer on the stack. Request is
  // heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestEmptyResponse>
  WithRequestEmptyResponse(::fidl::StringView arg) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(this->client_end(), arg);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>
  WithRequestEmptyResponse(::fidl::BufferSpan _request_buffer,
                           ::fidl::StringView arg,
                           ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }

  // Request is heap-allocated. Response is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestWithResponse>
  WithRequestWithResponse(::fidl::StringView arg) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(this->client_end(), arg);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>
  WithRequestWithResponse(::fidl::BufferSpan _request_buffer,
                          ::fidl::StringView arg,
                          ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(
        this->client_end(), _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method defined in |SyncEventHandler|. The return
  // status of the handler function is folded with any transport-level errors
  // and returned.
  ::fidl::Result HandleOneEvent(
      ::fidl::WireSyncEventHandler<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>&
          event_handler) {
    return event_handler.HandleOneEvent(client_end_);
  }

 private:
  ::fidl::ClientEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>
      client_end_;
};

// Pure-virtual interface to be implemented by a server.
// This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>|
// and |fidl::ServerEnd<SomeProtocol>|).
template <>
class ::fidl::WireInterface<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  WireInterface() = default;
  virtual ~WireInterface() = default;

  // The marker protocol type within which this |WireInterface| class is
  // defined.
  using _EnclosingProtocol =
      ::fidl_test_protocols::WithAndWithoutRequestResponse;

  using NoRequestNoResponseCompleter = ::fidl::Completer<>;

  virtual void NoRequestNoResponse(
      NoRequestNoResponseCompleter::Sync& _completer) = 0;

  class NoRequestEmptyResponseCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply();

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using NoRequestEmptyResponseCompleter =
      ::fidl::Completer<NoRequestEmptyResponseCompleterBase>;

  virtual void NoRequestEmptyResponse(
      NoRequestEmptyResponseCompleter::Sync& _completer) = 0;

  class NoRequestWithResponseCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(::fidl::StringView ret);
    ::fidl::Result Reply(::fidl::BufferSpan _buffer, ::fidl::StringView ret);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using NoRequestWithResponseCompleter =
      ::fidl::Completer<NoRequestWithResponseCompleterBase>;

  virtual void NoRequestWithResponse(
      NoRequestWithResponseCompleter::Sync& _completer) = 0;

  using WithRequestNoResponseCompleter = ::fidl::Completer<>;

  virtual void WithRequestNoResponse(
      ::fidl::StringView arg,
      WithRequestNoResponseCompleter::Sync& _completer) = 0;

  class WithRequestEmptyResponseCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply();

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using WithRequestEmptyResponseCompleter =
      ::fidl::Completer<WithRequestEmptyResponseCompleterBase>;

  virtual void WithRequestEmptyResponse(
      ::fidl::StringView arg,
      WithRequestEmptyResponseCompleter::Sync& _completer) = 0;

  class WithRequestWithResponseCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(::fidl::StringView ret);
    ::fidl::Result Reply(::fidl::BufferSpan _buffer, ::fidl::StringView ret);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using WithRequestWithResponseCompleter =
      ::fidl::Completer<WithRequestWithResponseCompleterBase>;

  virtual void WithRequestWithResponse(
      ::fidl::StringView arg,
      WithRequestWithResponseCompleter::Sync& _completer) = 0;

 private:
  ::fidl::DispatchResult dispatch_message(fidl_incoming_msg_t* msg,
                                          ::fidl::Transaction* txn) final;
};

namespace fidl_test_protocols {
extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxResponseAsStructRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxResponseAsStructResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsPrimitiveRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsPrimitiveResponseTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsEnumRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsEnumResponseTable;

class WithErrorSyntax final {
  WithErrorSyntax() = delete;

 public:
  class ResponseAsStruct final {
    ResponseAsStruct() = delete;
  };
  class ErrorAsPrimitive final {
    ErrorAsPrimitive() = delete;
  };
  class ErrorAsEnum final {
    ErrorAsEnum() = delete;
  };
};
}  // namespace fidl_test_protocols
#ifdef __Fuchsia__

template <>
struct ::fidl::internal::ProtocolDetails<
    ::fidl_test_protocols::WithErrorSyntax> {};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::WireDispatcher<::fidl_test_protocols::WithErrorSyntax>
    final {
  WireDispatcher() = delete;
  static ::fidl::DispatchResult TryDispatch(
      ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
  static ::fidl::DispatchResult Dispatch(
      ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>* impl,
      fidl_incoming_msg_t* msg, ::fidl::Transaction* txn);
};
#endif  // __Fuchsia__

template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType = ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result result;
  explicit WireResponse(
      ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result
          result)
      : result(result) {
    _InitHeader();
  }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithErrorSyntaxResponseAsStructResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 40;
  static constexpr uint32_t MaxOutOfLine = 24;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(
        uint8_t* _bytes, uint32_t _byte_size,
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result
            result)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{result};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>(
          &_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result
            result)
        : message_(bytes_.data(), bytes_.size(), result) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<64> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType = ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result result;
  explicit WireResponse(
      ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result
          result)
      : result(result) {
    _InitHeader();
  }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithErrorSyntaxErrorAsPrimitiveResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 40;
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(
        uint8_t* _bytes, uint32_t _byte_size,
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result
            result)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{result};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>(
          &_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result
            result)
        : message_(bytes_.data(), bytes_.size(), result) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<48> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
struct ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  explicit WireRequest(zx_txid_t _txid) { _InitHeader(_txid); }

  static constexpr const fidl_type_t* Type =
      &::fidl::_llcpp_coding_AnyZeroArgMessageTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr uint32_t AltPrimarySize = 16;
  static constexpr uint32_t AltMaxOutOfLine = 0;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = false;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kRequest;
  using ResponseType =
      ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(uint8_t* _bytes, uint32_t _byte_size, zx_txid_t _txid)
        : message_(_bytes, _byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireRequest _request(_txid);
      message_.Encode<WireRequest>(&_request);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireRequest* request)
        : message_(bytes, byte_size, sizeof(WireRequest), nullptr, 0, 0) {
      message_.Encode<WireRequest>(request);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(zx_txid_t _txid)
        : message_(bytes_.data(), bytes_.size(), _txid) {}
    explicit OwnedEncodedMessage(WireRequest* request)
        : message_(bytes_.data(), bytes_.size(), request) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<16> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<WireRequest>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<WireRequest>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireRequest* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<WireRequest*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader(zx_txid_t _txid);
};
template <>
struct ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
    final {
  FIDL_ALIGNDECL
  fidl_message_header_t _hdr;
  ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result result;
  explicit WireResponse(
      ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result result)
      : result(result) {
    _InitHeader();
  }
  WireResponse() { _InitHeader(); }

  static constexpr const fidl_type_t* Type =
      &::fidl_test_protocols::
          fidl_test_protocols_WithErrorSyntaxErrorAsEnumResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 40;
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasFlexibleEnvelope = false;
  static constexpr bool HasPointer = true;
  static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
      ::fidl::internal::TransactionalMessageKind::kResponse;

  class UnownedEncodedMessage final {
   public:
    UnownedEncodedMessage(
        uint8_t* _bytes, uint32_t _byte_size,
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result result)
        : message_(_bytes, _byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      FIDL_ALIGNDECL WireResponse _response{result};
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>(&_response);
    }
    UnownedEncodedMessage(uint8_t* bytes, uint32_t byte_size,
                          WireResponse* response)
        : message_(bytes, byte_size, sizeof(WireResponse), nullptr, 0, 0) {
      message_.Encode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>(response);
    }
    UnownedEncodedMessage(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage(UnownedEncodedMessage&&) = delete;
    UnownedEncodedMessage* operator=(const UnownedEncodedMessage&) = delete;
    UnownedEncodedMessage* operator=(UnownedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.status() == ZX_OK; }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() { return message_; }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::OutgoingMessage message_;
  };

  class OwnedEncodedMessage final {
   public:
    explicit OwnedEncodedMessage(
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result result)
        : message_(bytes_.data(), bytes_.size(), result) {}
    explicit OwnedEncodedMessage(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* response)
        : message_(bytes_.data(), bytes_.size(), response) {}
    OwnedEncodedMessage(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage(OwnedEncodedMessage&&) = delete;
    OwnedEncodedMessage* operator=(const OwnedEncodedMessage&) = delete;
    OwnedEncodedMessage* operator=(OwnedEncodedMessage&&) = delete;

    zx_status_t status() const { return message_.status(); }
#ifdef __Fuchsia__
    const char* status_string() const { return message_.status_string(); }
#endif  // __Fuchsia__
    bool ok() const { return message_.ok(); }
    const char* error() const { return message_.error(); }

    ::fidl::OutgoingMessage& GetOutgoingMessage() {
      return message_.GetOutgoingMessage();
    }
#ifdef __Fuchsia__
    template <typename ChannelLike>
    void Write(ChannelLike&& client) {
      message_.Write(std::forward<ChannelLike>(client));
    }
#endif  // __Fuchsia__
   private:
    ::fidl::internal::InlineMessageBuffer<48> bytes_;
    UnownedEncodedMessage message_;
  };

 public:
  class DecodedMessage final : public ::fidl::internal::IncomingMessage {
   public:
    DecodedMessage(uint8_t* bytes, uint32_t byte_actual,
                   zx_handle_info_t* handles = nullptr,
                   uint32_t handle_actual = 0)
        : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles,
                                            handle_actual) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>();
    }
    DecodedMessage(fidl_incoming_msg_t* msg)
        : ::fidl::internal::IncomingMessage(msg) {
      Decode<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>();
    }
    DecodedMessage(const DecodedMessage&) = delete;
    DecodedMessage(DecodedMessage&&) = delete;
    DecodedMessage* operator=(const DecodedMessage&) = delete;
    DecodedMessage* operator=(DecodedMessage&&) = delete;

    WireResponse* PrimaryObject() {
      ZX_DEBUG_ASSERT(ok());
      return reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes());
    }

    // Release the ownership of the decoded message. That means that the handles
    // won't be closed When the object is destroyed. After calling this method,
    // the DecodedMessage object should not be used anymore.
    void ReleasePrimaryObject() { ResetBytes(); }
  };

 private:
  void _InitHeader();
};
template <>
class ::fidl::WireResult<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
    final : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client,
      zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*>(
        bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*>(
        bytes_.data());
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<64> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client,
      uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*>(bytes_);
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
    final : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client,
      zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(
        bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(
        bytes_.data());
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<48> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client,
      uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(bytes_);
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};
template <>
class ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
    final : public ::fidl::Result {
 public:
  explicit WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client);
  WireResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client,
      zx_time_t _deadline);
  explicit WireResult(const ::fidl::Result& result) : ::fidl::Result(result) {}
  WireResult(WireResult&&) = delete;
  WireResult(const WireResult&) = delete;
  WireResult* operator=(WireResult&&) = delete;
  WireResult* operator=(const WireResult&) = delete;
  ~WireResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes_.data());
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes_.data());
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  operator*() const {
    return value();
  }

 private:
  ::fidl::internal::InlineMessageBuffer<48> bytes_;
};
template <>
class ::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
    final : public ::fidl::Result {
 public:
  explicit WireUnownedResult(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> _client,
      uint8_t* _response_bytes, uint32_t _response_byte_capacity);
  explicit WireUnownedResult(const ::fidl::Result& result)
      : ::fidl::Result(result) {}
  WireUnownedResult(WireUnownedResult&&) = delete;
  WireUnownedResult(const WireUnownedResult&) = delete;
  WireUnownedResult* operator=(WireUnownedResult&&) = delete;
  WireUnownedResult* operator=(const WireUnownedResult&) = delete;
  ~WireUnownedResult() = default;

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  Unwrap() {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes_);
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  Unwrap() const {
    ZX_DEBUG_ASSERT(ok());
    return reinterpret_cast<const ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes_);
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  value() {
    return *Unwrap();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  value() const {
    return *Unwrap();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  operator->() {
    return &value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
  operator->() const {
    return &value();
  }

  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  operator*() {
    return value();
  }
  const ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>&
  operator*() const {
    return value();
  }

 private:
  uint8_t* bytes_;
};

// Methods to make a sync FIDL call directly on an unowned channel or a
// const reference to a
// |fidl::ClientEnd<::fidl_test_protocols::WithErrorSyntax>|, avoiding setting
// up a client.
template <>
class ::fidl::internal::WireCaller<::fidl_test_protocols::WithErrorSyntax>
    final {
 public:
  explicit WireCaller(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
          client_end)
      : client_end_(client_end) {}

  // Allocates 80 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
          _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(_client_end);
  }
  // Allocates 80 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(client_end_);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
          _client_end,
      ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
        _client_end, _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct(::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
        client_end_, _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
          _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(_client_end);
  }
  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(client_end_);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
          _client_end,
      ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
        _client_end, _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive(::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
        client_end_, _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  static ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                  _client_end) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(_client_end);
  }
  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum() && {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(client_end_);
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  static ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                  _client_end,
              ::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
        _client_end, _response_buffer.data, _response_buffer.capacity);
  }
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum(::fidl::BufferSpan _response_buffer) && {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
        client_end_, _response_buffer.data, _response_buffer.capacity);
  }

 private:
  ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax> client_end_;
};
#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireEventHandlerInterface<
    ::fidl_test_protocols::WithErrorSyntax> {
 public:
  WireEventHandlerInterface() = default;
  virtual ~WireEventHandlerInterface() = default;
};

template <>
class ::fidl::WireAsyncEventHandler<::fidl_test_protocols::WithErrorSyntax>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::WithErrorSyntax> {
 public:
  WireAsyncEventHandler() = default;

  virtual void Unbound(::fidl::UnbindInfo info) {}
};

template <>
class ::fidl::WireSyncEventHandler<::fidl_test_protocols::WithErrorSyntax>
    : public ::fidl::internal::WireEventHandlerInterface<
          ::fidl_test_protocols::WithErrorSyntax> {
 public:
  WireSyncEventHandler() = default;

  // Method called when an unknown event is found. This methods gives the status
  // which, in this case, is returned by HandleOneEvent.
  virtual zx_status_t Unknown() = 0;

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the
  // corresponding virtual method.
  ::fidl::Result HandleOneEvent(
      ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
          client_end);
};
#endif  // __Fuchsia__

template <>
class ::fidl::WireSyncClient<::fidl_test_protocols::WithErrorSyntax> final {
 public:
  WireSyncClient() = default;

  explicit WireSyncClient(
      ::fidl::ClientEnd<::fidl_test_protocols::WithErrorSyntax> client_end)
      : client_end_(std::move(client_end)) {}

  ~WireSyncClient() = default;
  WireSyncClient(WireSyncClient&&) = default;
  WireSyncClient& operator=(WireSyncClient&&) = default;

  const ::fidl::ClientEnd<::fidl_test_protocols::WithErrorSyntax>& client_end()
      const {
    return client_end_;
  }
  ::fidl::ClientEnd<::fidl_test_protocols::WithErrorSyntax>& client_end() {
    return client_end_;
  }

  const ::zx::channel& channel() const { return client_end_.channel(); }
  ::zx::channel* mutable_channel() { return &client_end_.channel(); }

  // Allocates 80 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
        this->client_end());
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct(::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
        this->client_end(), _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
        this->client_end());
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive(::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
        this->client_end(), _response_buffer.data, _response_buffer.capacity);
  }

  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum() {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
        this->client_end());
  }

  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum(::fidl::BufferSpan _response_buffer) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
        this->client_end(), _response_buffer.data, _response_buffer.capacity);
  }

 private:
  ::fidl::ClientEnd<::fidl_test_protocols::WithErrorSyntax> client_end_;
};

// Pure-virtual interface to be implemented by a server.
// This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>|
// and |fidl::ServerEnd<SomeProtocol>|).
template <>
class ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>
    : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  WireInterface() = default;
  virtual ~WireInterface() = default;

  // The marker protocol type within which this |WireInterface| class is
  // defined.
  using _EnclosingProtocol = ::fidl_test_protocols::WithErrorSyntax;

  class ResponseAsStructCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result
            result);
    ::fidl::Result ReplySuccess(int64_t a, int64_t b, int64_t c);
    ::fidl::Result ReplyError(uint32_t error);
    ::fidl::Result Reply(
        ::fidl::BufferSpan _buffer,
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result
            result);
    ::fidl::Result ReplySuccess(::fidl::BufferSpan _buffer, int64_t a,
                                int64_t b, int64_t c);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using ResponseAsStructCompleter =
      ::fidl::Completer<ResponseAsStructCompleterBase>;

  virtual void ResponseAsStruct(
      ResponseAsStructCompleter::Sync& _completer) = 0;

  class ErrorAsPrimitiveCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result
            result);
    ::fidl::Result ReplySuccess();
    ::fidl::Result ReplyError(uint32_t error);
    ::fidl::Result Reply(
        ::fidl::BufferSpan _buffer,
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result
            result);
    ::fidl::Result ReplySuccess(::fidl::BufferSpan _buffer);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using ErrorAsPrimitiveCompleter =
      ::fidl::Completer<ErrorAsPrimitiveCompleterBase>;

  virtual void ErrorAsPrimitive(
      ErrorAsPrimitiveCompleter::Sync& _completer) = 0;

  class ErrorAsEnumCompleterBase : public ::fidl::CompleterBase {
   public:
    // In the following methods, the return value indicates internal errors
    // during the reply, such as encoding or writing to the transport. Note that
    // any error will automatically lead to the destruction of the binding,
    // after which the |on_unbound| callback will be triggered with a detailed
    // reason.
    //
    // See //zircon/system/ulib/fidl/include/lib/fidl/llcpp/server.h.
    //
    // Because the reply status is identical to the unbinding status, it can be
    // safely ignored.
    ::fidl::Result Reply(
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result result);
    ::fidl::Result ReplySuccess();
    ::fidl::Result ReplyError(::fidl_test_protocols::wire::ErrorEnun error);
    ::fidl::Result Reply(
        ::fidl::BufferSpan _buffer,
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result result);
    ::fidl::Result ReplySuccess(::fidl::BufferSpan _buffer);

   protected:
    using ::fidl::CompleterBase::CompleterBase;
  };

  using ErrorAsEnumCompleter = ::fidl::Completer<ErrorAsEnumCompleterBase>;

  virtual void ErrorAsEnum(ErrorAsEnumCompleter::Sync& _completer) = 0;

 private:
  ::fidl::DispatchResult dispatch_message(fidl_incoming_msg_t* msg,
                                          ::fidl::Transaction* txn) final;
};

namespace fidl {

template <>
struct IsFidlType<::fidl_test_protocols::wire::obj_type>
    : public std::true_type {};

template <>
struct IsFidlType<
    ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response>
    : public std::true_type {};
template <>
struct IsStruct<
    ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<::fidl_test_protocols::wire::
                                  WithErrorSyntax_ResponseAsStruct_Response>);
static_assert(
    offsetof(
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response,
        a) == 0);
static_assert(
    offsetof(
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response,
        b) == 8);
static_assert(
    offsetof(
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Response,
        c) == 16);
static_assert(sizeof(::fidl_test_protocols::wire::
                         WithErrorSyntax_ResponseAsStruct_Response) ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ResponseAsStruct_Response::PrimarySize);

template <>
struct IsFidlType<
    ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result>
    : public std::true_type {};
template <>
struct IsUnion<
    ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<
        ::fidl_test_protocols::wire::WithErrorSyntax_ResponseAsStruct_Result>);

template <>
struct IsFidlType<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Response>
    : public std::true_type {};
template <>
struct IsStruct<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Response>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<::fidl_test_protocols::wire::
                                  WithErrorSyntax_ErrorAsPrimitive_Response>);
static_assert(
    offsetof(
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Response,
        __reserved) == 0);
static_assert(sizeof(::fidl_test_protocols::wire::
                         WithErrorSyntax_ErrorAsPrimitive_Response) ==
              ::fidl_test_protocols::wire::
                  WithErrorSyntax_ErrorAsPrimitive_Response::PrimarySize);

template <>
struct IsFidlType<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result>
    : public std::true_type {};
template <>
struct IsUnion<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsPrimitive_Result>);

template <>
struct IsFidlType<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>
    : public std::true_type {};
template <>
struct IsStruct<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<
        ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response>);
static_assert(
    offsetof(::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response,
             __reserved) == 0);
static_assert(
    sizeof(::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response) ==
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Response::
        PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::DiscoverableProtocol::Method>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::DiscoverableProtocol::Method>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::DiscoverableProtocol::Method>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::DiscoverableProtocol::Method>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::Transitional::Request>::PrimarySize);
static_assert(
    offsetof(::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>,
             x) == 16);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>
    : public std::true_type {};
static_assert(
    sizeof(
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::Transitional::Request>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>,
             y) == 16);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::Transitional::OneWay>::PrimarySize);
static_assert(
    offsetof(::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay>,
             x) == 16);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::Transitional::Event>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>,
             x) == 16);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>>
    : public std::true_type {};
static_assert(
    sizeof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::ChannelProtocol::MethodA>::PrimarySize);
static_assert(
    offsetof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>,
        a) == 16);
static_assert(
    offsetof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>,
        b) == 24);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>>
    : public std::true_type {};
static_assert(
    sizeof(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::EventA>::PrimarySize);
static_assert(
    offsetof(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>,
        a) == 16);
static_assert(
    offsetof(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>,
        b) == 24);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>>
    : public std::true_type {};
static_assert(
    sizeof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::ChannelProtocol::MethodB>::PrimarySize);
static_assert(
    offsetof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>,
        a) == 16);
static_assert(
    offsetof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>,
        b) == 24);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::ChannelProtocol::MethodB>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MethodB>::PrimarySize);
static_assert(
    offsetof(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>,
        result) == 16);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::ChannelProtocol::TakeHandle>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>::PrimarySize);
static_assert(
    offsetof(
        ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>,
        h) == 16);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::ChannelProtocol::TakeHandle>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::ChannelProtocol::MutateSocket>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>::PrimarySize);
static_assert(
    offsetof(::fidl::WireRequest<
                 ::fidl_test_protocols::ChannelProtocol::MutateSocket>,
             a) == 16);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::ChannelProtocol::MutateSocket>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::MutateSocket>,
             b) == 16);

template <>
struct IsFidlType<::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               NoRequestNoResponse>) ==
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestNoResponse>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestEmptyResponse>> : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestEmptyResponse>> : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               NoRequestEmptyResponse>) ==
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestEmptyResponse>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>> : public std::true_type {
};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>> : public std::true_type {
};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               NoRequestEmptyResponse>) ==
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestWithResponse>> : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestWithResponse>> : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               NoRequestWithResponse>) ==
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestWithResponse>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestWithResponse>> : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestWithResponse>> : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               NoRequestWithResponse>) ==
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestWithResponse>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     NoRequestWithResponse>,
             ret) == 16);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestNoResponse>> : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestNoResponse>> : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               WithRequestNoResponse>) ==
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestNoResponse>::PrimarySize);
static_assert(
    offsetof(::fidl::WireRequest<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestNoResponse>,
             arg) == 16);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestEmptyResponse>> : public std::true_type {
};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestEmptyResponse>> : public std::true_type {
};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               WithRequestEmptyResponse>) ==
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestEmptyResponse>::PrimarySize);
static_assert(
    offsetof(::fidl::WireRequest<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestEmptyResponse>,
             arg) == 16);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               WithRequestEmptyResponse>) ==
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestWithResponse>> : public std::true_type {
};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestWithResponse>> : public std::true_type {
};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               WithRequestWithResponse>) ==
    ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestWithResponse>::PrimarySize);
static_assert(
    offsetof(::fidl::WireRequest<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestWithResponse>,
             arg) == 16);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>> : public std::true_type {
};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>> : public std::true_type {
};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               WithRequestWithResponse>) ==
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestWithResponse>,
             ret) == 16);

template <>
struct IsFidlType<::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               OnEmptyResponse>) ==
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             OnEmptyResponse>::PrimarySize);

template <>
struct IsFidlType<::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::OnWithResponse>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireResponse<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::OnWithResponse>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithAndWithoutRequestResponse::
               OnWithResponse>) ==
    ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             OnWithResponse>::PrimarySize);
static_assert(
    offsetof(
        ::fidl::WireResponse<::fidl_test_protocols::
                                 WithAndWithoutRequestResponse::OnWithResponse>,
        ret) == 16);

template <>
struct IsFidlType<::fidl_test_protocols::wire::ErrorEnun>
    : public std::true_type {};

template <>
struct IsFidlType<
    ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result>
    : public std::true_type {};
template <>
struct IsUnion<::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result>
    : public std::true_type {};
static_assert(std::is_standard_layout_v<
              ::fidl_test_protocols::wire::WithErrorSyntax_ErrorAsEnum_Result>);

template <>
struct IsFidlType<::fidl::WireRequest<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireRequest<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::PrimarySize);

template <>
struct IsFidlType<::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<
                 ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>,
             result) == 16);

template <>
struct IsFidlType<::fidl::WireRequest<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireRequest<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::PrimarySize);

template <>
struct IsFidlType<::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
    : public std::true_type {};
template <>
struct IsFidlMessage<::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::PrimarySize);
static_assert(
    offsetof(::fidl::WireResponse<
                 ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>,
             result) == 16);

template <>
struct IsFidlType<
    ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireRequest<
           ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>) ==
    ::fidl::WireRequest<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::PrimarySize);

template <>
struct IsFidlType<
    ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
    : public std::true_type {};
template <>
struct IsFidlMessage<
    ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
    : public std::true_type {};
static_assert(
    sizeof(::fidl::WireResponse<
           ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>) ==
    ::fidl::WireResponse<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::PrimarySize);
static_assert(offsetof(::fidl::WireResponse<
                           ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>,
                       result) == 16);

#ifdef __Fuchsia__
}  // namespace fidl
template <>
class ::fidl::internal::WireClientImpl<
    ::fidl_test_protocols::DiscoverableProtocol>
    final : private ::fidl::internal::ClientBase {
 public:
  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::Result Method();

  ::fidl::WireAsyncEventHandler<::fidl_test_protocols::DiscoverableProtocol>*
  event_handler() const {
    return event_handler_.get();
  }

 private:
  friend class ::fidl::Client<::fidl_test_protocols::DiscoverableProtocol>;
  friend class ::fidl::internal::ControlBlock<
      ::fidl_test_protocols::DiscoverableProtocol>;

  explicit WireClientImpl(std::shared_ptr<::fidl::WireAsyncEventHandler<
                              ::fidl_test_protocols::DiscoverableProtocol>>
                              event_handler)
      : event_handler_(std::move(event_handler)) {}

  std::optional<::fidl::UnbindInfo> DispatchEvent(
      fidl_incoming_msg_t* msg) override;

  std::shared_ptr<::fidl::WireAsyncEventHandler<
      ::fidl_test_protocols::DiscoverableProtocol>>
      event_handler_;
};
namespace fidl {
#endif  // __Fuchsia__

}  // namespace fidl
#ifdef __Fuchsia__
// |EventSender| owns a server endpoint of a channel speaking
// the DiscoverableProtocol protocol, and can send events in that protocol.
template <>
class ::fidl::WireEventSender<::fidl_test_protocols::DiscoverableProtocol> {
 public:
  // Constructs an event sender with an invalid channel.
  WireEventSender() = default;

  explicit WireEventSender(
      ::fidl::ServerEnd<::fidl_test_protocols::DiscoverableProtocol> server_end)
      : server_end_(std::move(server_end)) {}

  // The underlying server channel endpoint, which may be replaced at run-time.
  const ::fidl::ServerEnd<::fidl_test_protocols::DiscoverableProtocol>&
  server_end() const {
    return server_end_;
  }
  ::fidl::ServerEnd<::fidl_test_protocols::DiscoverableProtocol>& server_end() {
    return server_end_;
  }

  const ::zx::channel& channel() const { return server_end_.channel(); }
  ::zx::channel& channel() { return server_end_.channel(); }

  // Whether the underlying channel is valid.
  bool is_valid() const { return server_end_.is_valid(); }

 private:
  ::fidl::ServerEnd<::fidl_test_protocols::DiscoverableProtocol> server_end_;
};

template <>
class ::fidl::internal::WireWeakEventSender<
    ::fidl_test_protocols::DiscoverableProtocol> {
 public:
 private:
  friend class ::fidl::ServerBindingRef<
      ::fidl_test_protocols::DiscoverableProtocol>;

  explicit WireWeakEventSender(
      std::weak_ptr<::fidl::internal::AsyncServerBinding<
          ::fidl_test_protocols::DiscoverableProtocol>>
          binding)
      : binding_(std::move(binding)) {}

  std::weak_ptr<::fidl::internal::AsyncServerBinding<
      ::fidl_test_protocols::DiscoverableProtocol>>
      binding_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<::fidl_test_protocols::Transitional::Request>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
          message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireClientImpl<::fidl_test_protocols::Transitional>
    final : private ::fidl::internal::ClientBase {
 public:
  // Asynchronous variant of |Transitional.Request()|.
  // Allocates 24 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result Request(
      int64_t x,
      ::fit::callback<void(
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
              response)>
          _cb);

  // Asynchronous variant of |Transitional.Request()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result Request(
      ::fidl::BufferSpan _request_buffer, int64_t x,
      ::fidl::WireResponseContext<::fidl_test_protocols::Transitional::Request>*
          _context);

  // Synchronous variant of |Transitional.Request()|.
  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::Transitional::Request> Request_Sync(
      int64_t x);

  // Synchronous variant of |Transitional.Request()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request>
  Request_Sync(::fidl::BufferSpan _request_buffer, int64_t x,
               ::fidl::BufferSpan _response_buffer);

  // Allocates 24 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::Result OneWay(int64_t x);

  // Caller provides the backing storage for FIDL message via request buffer.
  ::fidl::Result OneWay(::fidl::BufferSpan _request_buffer, int64_t x);

  ::fidl::WireAsyncEventHandler<::fidl_test_protocols::Transitional>*
  event_handler() const {
    return event_handler_.get();
  }

 private:
  friend class ::fidl::Client<::fidl_test_protocols::Transitional>;
  friend class ::fidl::internal::ControlBlock<
      ::fidl_test_protocols::Transitional>;

  explicit WireClientImpl(
      std::shared_ptr<
          ::fidl::WireAsyncEventHandler<::fidl_test_protocols::Transitional>>
          event_handler)
      : event_handler_(std::move(event_handler)) {}

  std::optional<::fidl::UnbindInfo> DispatchEvent(
      fidl_incoming_msg_t* msg) override;

  std::shared_ptr<
      ::fidl::WireAsyncEventHandler<::fidl_test_protocols::Transitional>>
      event_handler_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__
// |EventSender| owns a server endpoint of a channel speaking
// the Transitional protocol, and can send events in that protocol.
template <>
class ::fidl::WireEventSender<::fidl_test_protocols::Transitional> {
 public:
  // Constructs an event sender with an invalid channel.
  WireEventSender() = default;

  explicit WireEventSender(
      ::fidl::ServerEnd<::fidl_test_protocols::Transitional> server_end)
      : server_end_(std::move(server_end)) {}

  // The underlying server channel endpoint, which may be replaced at run-time.
  const ::fidl::ServerEnd<::fidl_test_protocols::Transitional>& server_end()
      const {
    return server_end_;
  }
  ::fidl::ServerEnd<::fidl_test_protocols::Transitional>& server_end() {
    return server_end_;
  }

  const ::zx::channel& channel() const { return server_end_.channel(); }
  ::zx::channel& channel() { return server_end_.channel(); }

  // Whether the underlying channel is valid.
  bool is_valid() const { return server_end_.is_valid(); }

  zx_status_t Event(int64_t x) const;

  // Caller provides the backing storage for FIDL message via response buffers.
  zx_status_t Event(::fidl::BufferSpan _buffer, int64_t x) const;

 private:
  ::fidl::ServerEnd<::fidl_test_protocols::Transitional> server_end_;
};

template <>
class ::fidl::internal::WireWeakEventSender<
    ::fidl_test_protocols::Transitional> {
 public:
  zx_status_t Event(int64_t x) const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().Event(std::move(x));
    }
    return ZX_ERR_CANCELED;
  }

  // Caller provides the backing storage for FIDL message via response buffers.
  zx_status_t Event(::fidl::BufferSpan _buffer, int64_t x) const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().Event(std::move(_buffer), std::move(x));
    }
    return ZX_ERR_CANCELED;
  }

 private:
  friend class ::fidl::ServerBindingRef<::fidl_test_protocols::Transitional>;

  explicit WireWeakEventSender(
      std::weak_ptr<::fidl::internal::AsyncServerBinding<
          ::fidl_test_protocols::Transitional>>
          binding)
      : binding_(std::move(binding)) {}

  std::weak_ptr<
      ::fidl::internal::AsyncServerBinding<::fidl_test_protocols::Transitional>>
      binding_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::MethodB>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
          message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::TakeHandle>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>*
          message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>* message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>
    final : private ::fidl::internal::ClientBase {
 public:
  // Asynchronous variant of |ChannelProtocol.MethodB()|.
  // Allocates 32 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result MethodB(
      int64_t a, int64_t b,
      ::fit::callback<void(
          ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
              response)>
          _cb);

  // Asynchronous variant of |ChannelProtocol.MethodB()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result MethodB(
      ::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::ChannelProtocol::MethodB>* _context);

  // Synchronous variant of |ChannelProtocol.MethodB()|.
  // Allocates 56 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>
  MethodB_Sync(int64_t a, int64_t b);

  // Synchronous variant of |ChannelProtocol.MethodB()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodB>
  MethodB_Sync(::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
               ::fidl::BufferSpan _response_buffer);

  // Asynchronous variant of |ChannelProtocol.TakeHandle()|.
  // Allocates 24 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result TakeHandle(
      ::zx::handle&& h,
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::ChannelProtocol::TakeHandle>* response)>
          _cb);

  // Asynchronous variant of |ChannelProtocol.TakeHandle()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result TakeHandle(
      ::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>* _context);

  // Synchronous variant of |ChannelProtocol.TakeHandle()|.
  // Allocates 40 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle_Sync(::zx::handle&& h);

  // Synchronous variant of |ChannelProtocol.TakeHandle()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
  TakeHandle_Sync(::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
                  ::fidl::BufferSpan _response_buffer);

  // Asynchronous variant of |ChannelProtocol.MutateSocket()|.
  // Allocates 24 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result MutateSocket(
      ::zx::socket&& a,
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::ChannelProtocol::MutateSocket>* response)>
          _cb);

  // Asynchronous variant of |ChannelProtocol.MutateSocket()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result MutateSocket(
      ::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>* _context);

  // Synchronous variant of |ChannelProtocol.MutateSocket()|.
  // Allocates 48 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket_Sync(::zx::socket&& a);

  // Synchronous variant of |ChannelProtocol.MutateSocket()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>
  MutateSocket_Sync(::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
                    ::fidl::BufferSpan _response_buffer);

  // Allocates 32 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::Result MethodA(int64_t a, int64_t b);

  // Caller provides the backing storage for FIDL message via request buffer.
  ::fidl::Result MethodA(::fidl::BufferSpan _request_buffer, int64_t a,
                         int64_t b);

  ::fidl::WireAsyncEventHandler<::fidl_test_protocols::ChannelProtocol>*
  event_handler() const {
    return event_handler_.get();
  }

 private:
  friend class ::fidl::Client<::fidl_test_protocols::ChannelProtocol>;
  friend class ::fidl::internal::ControlBlock<
      ::fidl_test_protocols::ChannelProtocol>;

  explicit WireClientImpl(
      std::shared_ptr<
          ::fidl::WireAsyncEventHandler<::fidl_test_protocols::ChannelProtocol>>
          event_handler)
      : event_handler_(std::move(event_handler)) {}

  std::optional<::fidl::UnbindInfo> DispatchEvent(
      fidl_incoming_msg_t* msg) override;

  std::shared_ptr<
      ::fidl::WireAsyncEventHandler<::fidl_test_protocols::ChannelProtocol>>
      event_handler_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__
// |EventSender| owns a server endpoint of a channel speaking
// the ChannelProtocol protocol, and can send events in that protocol.
template <>
class ::fidl::WireEventSender<::fidl_test_protocols::ChannelProtocol> {
 public:
  // Constructs an event sender with an invalid channel.
  WireEventSender() = default;

  explicit WireEventSender(
      ::fidl::ServerEnd<::fidl_test_protocols::ChannelProtocol> server_end)
      : server_end_(std::move(server_end)) {}

  // The underlying server channel endpoint, which may be replaced at run-time.
  const ::fidl::ServerEnd<::fidl_test_protocols::ChannelProtocol>& server_end()
      const {
    return server_end_;
  }
  ::fidl::ServerEnd<::fidl_test_protocols::ChannelProtocol>& server_end() {
    return server_end_;
  }

  const ::zx::channel& channel() const { return server_end_.channel(); }
  ::zx::channel& channel() { return server_end_.channel(); }

  // Whether the underlying channel is valid.
  bool is_valid() const { return server_end_.is_valid(); }

  zx_status_t EventA(int64_t a, int64_t b) const;

  // Caller provides the backing storage for FIDL message via response buffers.
  zx_status_t EventA(::fidl::BufferSpan _buffer, int64_t a, int64_t b) const;

 private:
  ::fidl::ServerEnd<::fidl_test_protocols::ChannelProtocol> server_end_;
};

template <>
class ::fidl::internal::WireWeakEventSender<
    ::fidl_test_protocols::ChannelProtocol> {
 public:
  zx_status_t EventA(int64_t a, int64_t b) const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().EventA(std::move(a), std::move(b));
    }
    return ZX_ERR_CANCELED;
  }

  // Caller provides the backing storage for FIDL message via response buffers.
  zx_status_t EventA(::fidl::BufferSpan _buffer, int64_t a, int64_t b) const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().EventA(std::move(_buffer), std::move(a),
                                             std::move(b));
    }
    return ZX_ERR_CANCELED;
  }

 private:
  friend class ::fidl::ServerBindingRef<::fidl_test_protocols::ChannelProtocol>;

  explicit WireWeakEventSender(
      std::weak_ptr<::fidl::internal::AsyncServerBinding<
          ::fidl_test_protocols::ChannelProtocol>>
          binding)
      : binding_(std::move(binding)) {}

  std::weak_ptr<::fidl::internal::AsyncServerBinding<
      ::fidl_test_protocols::ChannelProtocol>>
      binding_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestEmptyResponse> : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(::fidl::WireResponse<
                       ::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestEmptyResponse>* message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(::fidl::WireResponse<
                       ::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>* message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestEmptyResponse> : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(::fidl::WireResponse<
                       ::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestEmptyResponse>* message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestWithResponse> : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(::fidl::WireResponse<
                       ::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>* message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>
    final : private ::fidl::internal::ClientBase {
 public:
  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestEmptyResponse()|. Allocates 16
  // bytes of request buffer on the stack. The callback is stored on the heap.
  ::fidl::Result NoRequestEmptyResponse(
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::WithAndWithoutRequestResponse::
                   NoRequestEmptyResponse>* response)>
          _cb);

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestEmptyResponse()|. Caller provides
  // the backing storage for FIDL message via request buffer. Ownership of
  // |_context| is given unsafely to the binding until |OnError| or |OnReply|
  // are called on it.
  ::fidl::Result NoRequestEmptyResponse(
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>* _context);

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestEmptyResponse()|. Allocates 32
  // bytes of message buffer on the stack. No heap allocation necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         NoRequestEmptyResponse>
  NoRequestEmptyResponse_Sync();

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestWithResponse()|. Allocates 16 bytes
  // of request buffer on the stack. The callback is stored on the heap.
  ::fidl::Result NoRequestWithResponse(
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::WithAndWithoutRequestResponse::
                   NoRequestWithResponse>* response)>
          _cb);

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestWithResponse()|. Caller provides
  // the backing storage for FIDL message via request buffer. Ownership of
  // |_context| is given unsafely to the binding until |OnError| or |OnReply|
  // are called on it.
  ::fidl::Result NoRequestWithResponse(
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>* _context);

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestWithResponse()|. Allocates 16 bytes
  // of request buffer on the stack. Response is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         NoRequestWithResponse>
  NoRequestWithResponse_Sync();

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.NoRequestWithResponse()|. Caller provides
  // the backing storage for FIDL message via request and response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>
  NoRequestWithResponse_Sync(::fidl::BufferSpan _response_buffer);

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestEmptyResponse()|. The request and
  // callback are allocated on the heap.
  ::fidl::Result WithRequestEmptyResponse(
      ::fidl::StringView arg,
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::WithAndWithoutRequestResponse::
                   WithRequestEmptyResponse>* response)>
          _cb);

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestEmptyResponse()|. Caller provides
  // the backing storage for FIDL message via request buffer. Ownership of
  // |_context| is given unsafely to the binding until |OnError| or |OnReply|
  // are called on it.
  ::fidl::Result WithRequestEmptyResponse(
      ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg,
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>* _context);

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestEmptyResponse()|. Allocates 16
  // bytes of response buffer on the stack. Request is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestEmptyResponse>
  WithRequestEmptyResponse_Sync(::fidl::StringView arg);

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestEmptyResponse()|. Caller provides
  // the backing storage for FIDL message via request and response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>
  WithRequestEmptyResponse_Sync(::fidl::BufferSpan _request_buffer,
                                ::fidl::StringView arg,
                                ::fidl::BufferSpan _response_buffer);

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestWithResponse()|. The request and
  // callback are allocated on the heap.
  ::fidl::Result WithRequestWithResponse(
      ::fidl::StringView arg,
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::WithAndWithoutRequestResponse::
                   WithRequestWithResponse>* response)>
          _cb);

  // Asynchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestWithResponse()|. Caller provides
  // the backing storage for FIDL message via request buffer. Ownership of
  // |_context| is given unsafely to the binding until |OnError| or |OnReply|
  // are called on it.
  ::fidl::Result WithRequestWithResponse(
      ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg,
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>* _context);

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestWithResponse()|. Request is
  // heap-allocated. Response is heap-allocated.
  ::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                         WithRequestWithResponse>
  WithRequestWithResponse_Sync(::fidl::StringView arg);

  // Synchronous variant of
  // |WithAndWithoutRequestResponse.WithRequestWithResponse()|. Caller provides
  // the backing storage for FIDL message via request and response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>
  WithRequestWithResponse_Sync(::fidl::BufferSpan _request_buffer,
                               ::fidl::StringView arg,
                               ::fidl::BufferSpan _response_buffer);

  // Allocates 16 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::Result NoRequestNoResponse();

  // Request is heap-allocated.
  ::fidl::Result WithRequestNoResponse(::fidl::StringView arg);

  // Caller provides the backing storage for FIDL message via request buffer.
  ::fidl::Result WithRequestNoResponse(::fidl::BufferSpan _request_buffer,
                                       ::fidl::StringView arg);

  ::fidl::WireAsyncEventHandler<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>*
  event_handler() const {
    return event_handler_.get();
  }

 private:
  friend class ::fidl::Client<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>;
  friend class ::fidl::internal::ControlBlock<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>;

  explicit WireClientImpl(
      std::shared_ptr<::fidl::WireAsyncEventHandler<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>>
          event_handler)
      : event_handler_(std::move(event_handler)) {}

  std::optional<::fidl::UnbindInfo> DispatchEvent(
      fidl_incoming_msg_t* msg) override;

  std::shared_ptr<::fidl::WireAsyncEventHandler<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>>
      event_handler_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__
// |EventSender| owns a server endpoint of a channel speaking
// the WithAndWithoutRequestResponse protocol, and can send events in that
// protocol.
template <>
class ::fidl::WireEventSender<
    ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  // Constructs an event sender with an invalid channel.
  WireEventSender() = default;

  explicit WireEventSender(
      ::fidl::ServerEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>
          server_end)
      : server_end_(std::move(server_end)) {}

  // The underlying server channel endpoint, which may be replaced at run-time.
  const ::fidl::ServerEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>&
  server_end() const {
    return server_end_;
  }
  ::fidl::ServerEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>&
  server_end() {
    return server_end_;
  }

  const ::zx::channel& channel() const { return server_end_.channel(); }
  ::zx::channel& channel() { return server_end_.channel(); }

  // Whether the underlying channel is valid.
  bool is_valid() const { return server_end_.is_valid(); }

  zx_status_t OnEmptyResponse() const;

  zx_status_t OnWithResponse(::fidl::StringView ret) const;

  // Caller provides the backing storage for FIDL message via response buffers.
  zx_status_t OnWithResponse(::fidl::BufferSpan _buffer,
                             ::fidl::StringView ret) const;

 private:
  ::fidl::ServerEnd<::fidl_test_protocols::WithAndWithoutRequestResponse>
      server_end_;
};

template <>
class ::fidl::internal::WireWeakEventSender<
    ::fidl_test_protocols::WithAndWithoutRequestResponse> {
 public:
  zx_status_t OnEmptyResponse() const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().OnEmptyResponse();
    }
    return ZX_ERR_CANCELED;
  }

  zx_status_t OnWithResponse(::fidl::StringView ret) const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().OnWithResponse(std::move(ret));
    }
    return ZX_ERR_CANCELED;
  }

  // Caller provides the backing storage for FIDL message via response buffers.
  zx_status_t OnWithResponse(::fidl::BufferSpan _buffer,
                             ::fidl::StringView ret) const {
    if (auto _binding = binding_.lock()) {
      return _binding->event_sender().OnWithResponse(std::move(_buffer),
                                                     std::move(ret));
    }
    return ZX_ERR_CANCELED;
  }

 private:
  friend class ::fidl::ServerBindingRef<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>;

  explicit WireWeakEventSender(
      std::weak_ptr<::fidl::internal::AsyncServerBinding<
          ::fidl_test_protocols::WithAndWithoutRequestResponse>>
          binding)
      : binding_(std::move(binding)) {}

  std::weak_ptr<::fidl::internal::AsyncServerBinding<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>>
      binding_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
          message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
          message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
    : public ::fidl::internal::ResponseContext {
 public:
  WireResponseContext();

  virtual void OnReply(
      ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*
          message) = 0;

 private:
  void OnReply(uint8_t* reply) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::WireClientImpl<::fidl_test_protocols::WithErrorSyntax>
    final : private ::fidl::internal::ClientBase {
 public:
  // Asynchronous variant of |WithErrorSyntax.ResponseAsStruct()|.
  // Allocates 16 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result ResponseAsStruct(
      ::fit::callback<
          void(::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                        ResponseAsStruct>* response)>
          _cb);

  // Asynchronous variant of |WithErrorSyntax.ResponseAsStruct()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result ResponseAsStruct(
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>* _context);

  // Synchronous variant of |WithErrorSyntax.ResponseAsStruct()|.
  // Allocates 80 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct_Sync();

  // Synchronous variant of |WithErrorSyntax.ResponseAsStruct()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
  ResponseAsStruct_Sync(::fidl::BufferSpan _response_buffer);

  // Asynchronous variant of |WithErrorSyntax.ErrorAsPrimitive()|.
  // Allocates 16 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result ErrorAsPrimitive(
      ::fit::callback<
          void(::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                        ErrorAsPrimitive>* response)>
          _cb);

  // Asynchronous variant of |WithErrorSyntax.ErrorAsPrimitive()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result ErrorAsPrimitive(
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>* _context);

  // Synchronous variant of |WithErrorSyntax.ErrorAsPrimitive()|.
  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive_Sync();

  // Synchronous variant of |WithErrorSyntax.ErrorAsPrimitive()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
  ErrorAsPrimitive_Sync(::fidl::BufferSpan _response_buffer);

  // Asynchronous variant of |WithErrorSyntax.ErrorAsEnum()|.
  // Allocates 16 bytes of request buffer on the stack. The callback is stored
  // on the heap.
  ::fidl::Result ErrorAsEnum(
      ::fit::callback<
          void(::fidl::WireResponse<
               ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* response)>
          _cb);

  // Asynchronous variant of |WithErrorSyntax.ErrorAsEnum()|.
  // Caller provides the backing storage for FIDL message via request buffer.
  // Ownership of |_context| is given unsafely to the binding until |OnError|
  // or |OnReply| are called on it.
  ::fidl::Result ErrorAsEnum(
      ::fidl::WireResponseContext<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* _context);

  // Synchronous variant of |WithErrorSyntax.ErrorAsEnum()|.
  // Allocates 64 bytes of message buffer on the stack. No heap allocation
  // necessary.
  ::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum_Sync();

  // Synchronous variant of |WithErrorSyntax.ErrorAsEnum()|.
  // Caller provides the backing storage for FIDL message via request and
  // response buffers.
  ::fidl::WireUnownedResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
  ErrorAsEnum_Sync(::fidl::BufferSpan _response_buffer);

  ::fidl::WireAsyncEventHandler<::fidl_test_protocols::WithErrorSyntax>*
  event_handler() const {
    return event_handler_.get();
  }

 private:
  friend class ::fidl::Client<::fidl_test_protocols::WithErrorSyntax>;
  friend class ::fidl::internal::ControlBlock<
      ::fidl_test_protocols::WithErrorSyntax>;

  explicit WireClientImpl(
      std::shared_ptr<
          ::fidl::WireAsyncEventHandler<::fidl_test_protocols::WithErrorSyntax>>
          event_handler)
      : event_handler_(std::move(event_handler)) {}

  std::optional<::fidl::UnbindInfo> DispatchEvent(
      fidl_incoming_msg_t* msg) override;

  std::shared_ptr<
      ::fidl::WireAsyncEventHandler<::fidl_test_protocols::WithErrorSyntax>>
      event_handler_;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__
// |EventSender| owns a server endpoint of a channel speaking
// the WithErrorSyntax protocol, and can send events in that protocol.
template <>
class ::fidl::WireEventSender<::fidl_test_protocols::WithErrorSyntax> {
 public:
  // Constructs an event sender with an invalid channel.
  WireEventSender() = default;

  explicit WireEventSender(
      ::fidl::ServerEnd<::fidl_test_protocols::WithErrorSyntax> server_end)
      : server_end_(std::move(server_end)) {}

  // The underlying server channel endpoint, which may be replaced at run-time.
  const ::fidl::ServerEnd<::fidl_test_protocols::WithErrorSyntax>& server_end()
      const {
    return server_end_;
  }
  ::fidl::ServerEnd<::fidl_test_protocols::WithErrorSyntax>& server_end() {
    return server_end_;
  }

  const ::zx::channel& channel() const { return server_end_.channel(); }
  ::zx::channel& channel() { return server_end_.channel(); }

  // Whether the underlying channel is valid.
  bool is_valid() const { return server_end_.is_valid(); }

 private:
  ::fidl::ServerEnd<::fidl_test_protocols::WithErrorSyntax> server_end_;
};

template <>
class ::fidl::internal::WireWeakEventSender<
    ::fidl_test_protocols::WithErrorSyntax> {
 public:
 private:
  friend class ::fidl::ServerBindingRef<::fidl_test_protocols::WithErrorSyntax>;

  explicit WireWeakEventSender(
      std::weak_ptr<::fidl::internal::AsyncServerBinding<
          ::fidl_test_protocols::WithErrorSyntax>>
          binding)
      : binding_(std::move(binding)) {}

  std::weak_ptr<::fidl::internal::AsyncServerBinding<
      ::fidl_test_protocols::WithErrorSyntax>>
      binding_;
};
#endif  // __Fuchsia__