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

#pragma once

#include "lib/fidl/cpp/internal/header.h"

namespace test {
namespace emptystruct {

//
// Domain objects declarations
//

class Empty;

class EmptyProtocolSendRequest;

class EmptyProtocolSendAndReceiveTopResponse;

class EmptyProtocolSendAndReceiveRequest;

class EmptyProtocolReceiveRequest;

#ifdef __Fuchsia__

class EmptyProtocol;
using EmptyProtocolHandle = ::fidl::InterfaceHandle<EmptyProtocol>;
#endif  // __Fuchsia__

class Empty final {
 public:
  static const fidl_type_t* FidlType;

  uint8_t __reserved = 0u;

  static inline ::std::unique_ptr<Empty> New() { return ::std::make_unique<Empty>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, Empty* value, size_t _offset);
  zx_status_t Clone(Empty* result) const;
};

inline zx_status_t Clone(const ::test::emptystruct::Empty& _value,
                         ::test::emptystruct::Empty* _result) {
  return _value.Clone(_result);
}

using EmptyPtr = ::std::unique_ptr<Empty>;

class EmptyProtocolSendRequest final {
 public:
  static const fidl_type_t* FidlType;

  ::test::emptystruct::Empty e{};

  static inline ::std::unique_ptr<EmptyProtocolSendRequest> New() { return ::std::make_unique<EmptyProtocolSendRequest>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, EmptyProtocolSendRequest* value, size_t _offset);
  zx_status_t Clone(EmptyProtocolSendRequest* result) const;
};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolSendRequest& _value,
                         ::test::emptystruct::EmptyProtocolSendRequest* _result) {
  return _value.Clone(_result);
}

using EmptyProtocolSendRequestPtr = ::std::unique_ptr<EmptyProtocolSendRequest>;

class EmptyProtocolSendAndReceiveTopResponse final {
 public:
  static const fidl_type_t* FidlType;

  ::test::emptystruct::Empty e{};

  static inline ::std::unique_ptr<EmptyProtocolSendAndReceiveTopResponse> New() { return ::std::make_unique<EmptyProtocolSendAndReceiveTopResponse>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, EmptyProtocolSendAndReceiveTopResponse* value, size_t _offset);
  zx_status_t Clone(EmptyProtocolSendAndReceiveTopResponse* result) const;
};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse& _value,
                         ::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse* _result) {
  return _value.Clone(_result);
}

using EmptyProtocolSendAndReceiveTopResponsePtr = ::std::unique_ptr<EmptyProtocolSendAndReceiveTopResponse>;

class EmptyProtocolSendAndReceiveRequest final {
 public:
  static const fidl_type_t* FidlType;

  ::test::emptystruct::Empty e{};

  static inline ::std::unique_ptr<EmptyProtocolSendAndReceiveRequest> New() { return ::std::make_unique<EmptyProtocolSendAndReceiveRequest>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, EmptyProtocolSendAndReceiveRequest* value, size_t _offset);
  zx_status_t Clone(EmptyProtocolSendAndReceiveRequest* result) const;
};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolSendAndReceiveRequest& _value,
                         ::test::emptystruct::EmptyProtocolSendAndReceiveRequest* _result) {
  return _value.Clone(_result);
}

using EmptyProtocolSendAndReceiveRequestPtr = ::std::unique_ptr<EmptyProtocolSendAndReceiveRequest>;

class EmptyProtocolReceiveRequest final {
 public:
  static const fidl_type_t* FidlType;

  ::test::emptystruct::Empty e{};

  static inline ::std::unique_ptr<EmptyProtocolReceiveRequest> New() { return ::std::make_unique<EmptyProtocolReceiveRequest>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, EmptyProtocolReceiveRequest* value, size_t _offset);
  zx_status_t Clone(EmptyProtocolReceiveRequest* result) const;
};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolReceiveRequest& _value,
                         ::test::emptystruct::EmptyProtocolReceiveRequest* _result) {
  return _value.Clone(_result);
}

using EmptyProtocolReceiveRequestPtr = ::std::unique_ptr<EmptyProtocolReceiveRequest>;

#ifdef __Fuchsia__

namespace _internal {
__LOCAL extern "C" const fidl_type_t test_emptystruct_EmptyProtocolSendRequestTable;

__LOCAL extern "C" const fidl_type_t test_emptystruct_EmptyProtocolSendAndReceiveRequestTable;

}  // namespace _internal
class EmptyProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage Send(::fidl::MessageEncoder* _encoder, ::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(1);
    ::fidl::Encode(_encoder, e, 0 + sizeof(fidl_message_header_t));

    fidl_trace(DidHLCPPEncode, &::test::emptystruct::_internal::test_emptystruct_EmptyProtocolSendRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount());

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage SendAndReceive(::fidl::MessageEncoder* _encoder, ::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);
    _encoder->Alloc(1);
    ::fidl::Encode(_encoder, e, 0 + sizeof(fidl_message_header_t));

    fidl_trace(DidHLCPPEncode, &::test::emptystruct::_internal::test_emptystruct_EmptyProtocolSendAndReceiveRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount());

    return _encoder->GetMessage();
  }
};

namespace _internal {
__LOCAL extern "C" const fidl_type_t test_emptystruct_EmptyProtocolReceiveRequestTable;
__LOCAL extern "C" const fidl_type_t test_emptystruct_EmptyProtocolSendAndReceiveTopResponseTable;

}  // namespace _internal
class EmptyProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage Receive(::fidl::MessageEncoder* _encoder, ::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);

    _encoder->Alloc(1);
    ::fidl::Encode(_encoder, e, 0 + sizeof(fidl_message_header_t));

    fidl_trace(DidHLCPPEncode, &::test::emptystruct::_internal::test_emptystruct_EmptyProtocolReceiveRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount());

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage SendAndReceive(::fidl::MessageEncoder* _encoder, ::test::emptystruct::Empty* e) {
    fidl_trace(WillHLCPPEncode);

    _encoder->Alloc(1);
    ::fidl::Encode(_encoder, e, 0 + sizeof(fidl_message_header_t));

    fidl_trace(DidHLCPPEncode, &::test::emptystruct::_internal::test_emptystruct_EmptyProtocolSendAndReceiveTopResponseTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount());

    return _encoder->GetMessage();
  }
};
#endif  // __Fuchsia__

}  // namespace emptystruct
}  // namespace test
namespace fidl {
template <>
struct CodingTraits<::test::emptystruct::Empty>
    : public EncodableCodingTraits<::test::emptystruct::Empty, 1> {};

template <>
struct IsMemcpyCompatible<::test::emptystruct::Empty> : public internal::BoolConstant<
                                                            !HasPadding<::test::emptystruct::Empty>::value && IsMemcpyCompatible<uint8_t>::value> {};

inline zx_status_t Clone(const ::test::emptystruct::Empty& value,
                         ::test::emptystruct::Empty* result) {
  return ::test::emptystruct::Clone(value, result);
}

template <>
struct Equality<::test::emptystruct::Empty> {
  bool operator()(const ::test::emptystruct::Empty& _lhs, const ::test::emptystruct::Empty& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::emptystruct::EmptyProtocolSendRequest>
    : public EncodableCodingTraits<::test::emptystruct::EmptyProtocolSendRequest, 1> {};

template <>
struct IsMemcpyCompatible<::test::emptystruct::EmptyProtocolSendRequest> : public internal::BoolConstant<
                                                                               !HasPadding<::test::emptystruct::EmptyProtocolSendRequest>::value && IsMemcpyCompatible<::test::emptystruct::Empty>::value> {};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolSendRequest& value,
                         ::test::emptystruct::EmptyProtocolSendRequest* result) {
  return ::test::emptystruct::Clone(value, result);
}

template <>
struct Equality<::test::emptystruct::EmptyProtocolSendRequest> {
  bool operator()(const ::test::emptystruct::EmptyProtocolSendRequest& _lhs, const ::test::emptystruct::EmptyProtocolSendRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.e, _rhs.e)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse>
    : public EncodableCodingTraits<::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse, 1> {};

template <>
struct IsMemcpyCompatible<::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse> : public internal::BoolConstant<
                                                                                             !HasPadding<::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse>::value && IsMemcpyCompatible<::test::emptystruct::Empty>::value> {};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse& value,
                         ::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse* result) {
  return ::test::emptystruct::Clone(value, result);
}

template <>
struct Equality<::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse> {
  bool operator()(const ::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse& _lhs, const ::test::emptystruct::EmptyProtocolSendAndReceiveTopResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.e, _rhs.e)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::emptystruct::EmptyProtocolSendAndReceiveRequest>
    : public EncodableCodingTraits<::test::emptystruct::EmptyProtocolSendAndReceiveRequest, 1> {};

template <>
struct IsMemcpyCompatible<::test::emptystruct::EmptyProtocolSendAndReceiveRequest> : public internal::BoolConstant<
                                                                                         !HasPadding<::test::emptystruct::EmptyProtocolSendAndReceiveRequest>::value && IsMemcpyCompatible<::test::emptystruct::Empty>::value> {};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolSendAndReceiveRequest& value,
                         ::test::emptystruct::EmptyProtocolSendAndReceiveRequest* result) {
  return ::test::emptystruct::Clone(value, result);
}

template <>
struct Equality<::test::emptystruct::EmptyProtocolSendAndReceiveRequest> {
  bool operator()(const ::test::emptystruct::EmptyProtocolSendAndReceiveRequest& _lhs, const ::test::emptystruct::EmptyProtocolSendAndReceiveRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.e, _rhs.e)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::emptystruct::EmptyProtocolReceiveRequest>
    : public EncodableCodingTraits<::test::emptystruct::EmptyProtocolReceiveRequest, 1> {};

template <>
struct IsMemcpyCompatible<::test::emptystruct::EmptyProtocolReceiveRequest> : public internal::BoolConstant<
                                                                                  !HasPadding<::test::emptystruct::EmptyProtocolReceiveRequest>::value && IsMemcpyCompatible<::test::emptystruct::Empty>::value> {};

inline zx_status_t Clone(const ::test::emptystruct::EmptyProtocolReceiveRequest& value,
                         ::test::emptystruct::EmptyProtocolReceiveRequest* result) {
  return ::test::emptystruct::Clone(value, result);
}

template <>
struct Equality<::test::emptystruct::EmptyProtocolReceiveRequest> {
  bool operator()(const ::test::emptystruct::EmptyProtocolReceiveRequest& _lhs, const ::test::emptystruct::EmptyProtocolReceiveRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.e, _rhs.e)) {
      return false;
    }
    return true;
  }
};

//
// Proxies and stubs declarations
//
}  // namespace fidl
namespace test {
namespace emptystruct {
#ifdef __Fuchsia__

using EmptyProtocolPtr = ::fidl::InterfacePtr<EmptyProtocol>;
class EmptyProtocol_Proxy;
class EmptyProtocol_Stub;
class EmptyProtocol_EventSender;
class EmptyProtocol_Sync;
using EmptyProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<EmptyProtocol>;
class EmptyProtocol_SyncProxy;

namespace internal {
constexpr uint64_t kEmptyProtocol_Send_Ordinal = 0x132262fd8b200708lu;
constexpr ::fidl::MessageDynamicFlags kEmptyProtocol_Send_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
constexpr uint64_t kEmptyProtocol_Receive_Ordinal = 0x1ff0ccf9b710e23flu;
constexpr ::fidl::MessageDynamicFlags kEmptyProtocol_Receive_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
constexpr uint64_t kEmptyProtocol_SendAndReceive_Ordinal = 0x76a931254962cealu;
constexpr ::fidl::MessageDynamicFlags kEmptyProtocol_SendAndReceive_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
}  // namespace internal
#endif  // __Fuchsia__

#ifdef __Fuchsia__

class EmptyProtocol {
 public:
  using Proxy_ = ::test::emptystruct::EmptyProtocol_Proxy;
  using Stub_ = ::test::emptystruct::EmptyProtocol_Stub;
  using EventSender_ = ::test::emptystruct::EmptyProtocol_EventSender;
  using Sync_ = ::test::emptystruct::EmptyProtocol_Sync;
  virtual ~EmptyProtocol();

  virtual void Send(::test::emptystruct::Empty e) = 0;
  using ReceiveCallback =
      fit::function<void(::test::emptystruct::Empty)>;
  using SendAndReceiveCallback =
      fit::function<void(::test::emptystruct::Empty)>;

  virtual void SendAndReceive(::test::emptystruct::Empty e, SendAndReceiveCallback callback) = 0;
};

class EmptyProtocol_RequestDecoder {
 public:
  EmptyProtocol_RequestDecoder() = default;
  virtual ~EmptyProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response);
  virtual void Send(::test::emptystruct::Empty e) = 0;
  virtual void SendAndReceive(::test::emptystruct::Empty e) = 0;
};

class EmptyProtocol_ResponseDecoder {
 public:
  EmptyProtocol_ResponseDecoder() = default;
  virtual ~EmptyProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void Receive(::test::emptystruct::Empty e) = 0;
  virtual void SendAndReceive(::test::emptystruct::Empty e) = 0;
};

class EmptyProtocol_EventSender {
 public:
  virtual ~EmptyProtocol_EventSender();
  virtual void Receive(::test::emptystruct::Empty e) = 0;
};

class EmptyProtocol_Sync {
 public:
  using Proxy_ = ::test::emptystruct::EmptyProtocol_SyncProxy;
  virtual ~EmptyProtocol_Sync();
  virtual zx_status_t Send(::test::emptystruct::Empty e) = 0;
  virtual zx_status_t SendAndReceive(::test::emptystruct::Empty e, ::test::emptystruct::Empty* out_e) = 0;
};

class EmptyProtocol_Proxy final : public ::fidl::internal::Proxy, public EmptyProtocol {
 public:
  explicit EmptyProtocol_Proxy(::fidl::internal::ProxyController* controller);
  ~EmptyProtocol_Proxy() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.emptystruct/EmptyProtocol.Send
  void Send(::test::emptystruct::Empty e) override;
  ReceiveCallback Receive;
  // cts-coverage-fidl-name:test.emptystruct/EmptyProtocol.SendAndReceive
  void SendAndReceive(::test::emptystruct::Empty e, SendAndReceiveCallback callback) override;

 private:
  EmptyProtocol_Proxy(const ::test::emptystruct::EmptyProtocol_Proxy&) = delete;
  EmptyProtocol_Proxy& operator=(const ::test::emptystruct::EmptyProtocol_Proxy&) = delete;

  ::fidl::internal::ProxyController* controller_;
};

class EmptyProtocol_Stub final : public ::fidl::internal::Stub, public ::test::emptystruct::EmptyProtocol_EventSender {
 public:
  typedef class ::test::emptystruct::EmptyProtocol EmptyProtocol_clazz;
  explicit EmptyProtocol_Stub(::test::emptystruct::EmptyProtocol_Stub::EmptyProtocol_clazz* impl);
  ~EmptyProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void Receive(::test::emptystruct::Empty e) override;

 private:
  ::test::emptystruct::EmptyProtocol_Stub::EmptyProtocol_clazz* impl_;
};

class EmptyProtocol_SyncProxy : public ::test::emptystruct::EmptyProtocol_Sync {
 public:
  explicit EmptyProtocol_SyncProxy(::zx::channel channel);
  ~EmptyProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.emptystruct/EmptyProtocol.Send
  zx_status_t Send(::test::emptystruct::Empty e) override;
  // cts-coverage-fidl-name:test.emptystruct/EmptyProtocol.SendAndReceive
  zx_status_t SendAndReceive(::test::emptystruct::Empty e, ::test::emptystruct::Empty* out_e) override;

 private:
  ::fidl::internal::SynchronousProxy proxy_;
  friend class ::fidl::SynchronousInterfacePtr<EmptyProtocol>;
};
#endif  // __Fuchsia__

}  // namespace emptystruct
}  // namespace test