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

#pragma once

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

namespace fidl {
namespace test {
namespace json {

#ifdef __Fuchsia__

class Parent;
using ParentPtr = ::fidl::InterfacePtr<Parent>;
class Parent_Proxy;
class Parent_Stub;
class Parent_EventSender;
class Parent_Sync;
using ParentSyncPtr = ::fidl::SynchronousInterfacePtr<Parent>;
class Parent_SyncProxy;
using ParentHandle = ::fidl::InterfaceHandle<Parent>;
namespace internal {
constexpr uint64_t kParent_First_Ordinal = 0x66a95ddc00000000lu;
constexpr uint64_t kParent_First_GenOrdinal = 0x239f8fdea8de880clu;

}  // namespace internal
#endif  // __Fuchsia__
#ifdef __Fuchsia__

class Child;
using ChildPtr = ::fidl::InterfacePtr<Child>;
class Child_Proxy;
class Child_Stub;
class Child_EventSender;
class Child_Sync;
using ChildSyncPtr = ::fidl::SynchronousInterfacePtr<Child>;
class Child_SyncProxy;
using ChildHandle = ::fidl::InterfaceHandle<Child>;
namespace internal {
constexpr uint64_t kChild_First_Ordinal = 0x66a95ddc00000000lu;
constexpr uint64_t kChild_First_GenOrdinal = 0x239f8fdea8de880clu;
constexpr uint64_t kChild_Second_Ordinal = 0x1240cb600000000lu;
constexpr uint64_t kChild_Second_GenOrdinal = 0x24799ea8916d88aflu;

}  // namespace internal
#endif  // __Fuchsia__
#ifdef __Fuchsia__

class Parent {
 public:
  using Proxy_ = Parent_Proxy;
  using Stub_ = Parent_Stub;
  using EventSender_ = Parent_EventSender;
  using Sync_ = Parent_Sync;
  virtual ~Parent();

  virtual void First(::fidl::InterfaceRequest<Parent> request) = 0;
};

class Parent_RequestEncoder {
 public:
  static ::fidl::Message First(::fidl::Encoder* _encoder,
                               ::fidl::InterfaceRequest<Parent>* request) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, request, 16);
    return _encoder->GetMessage();
  }
};

class Parent_RequestDecoder {
 public:
  Parent_RequestDecoder() = default;
  virtual ~Parent_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response);
  zx_status_t Decode_(::fidl::Message request) {
    bool needs_response;
    const fidl_type_t* request_type =
        GetType(request.ordinal(), &needs_response);
    if (request_type == nullptr) {
      return ZX_ERR_NOT_SUPPORTED;
    }
    const char* error_msg = nullptr;
    zx_status_t status = request.Decode(request_type, &error_msg);
    if (status != ZX_OK) {
      FIDL_REPORT_DECODING_ERROR(request, request_type, error_msg);
      return status;
    }
    ::fidl::Decoder request_decoder(std::move(request));
    switch (request.ordinal()) {
      case internal::kParent_First_Ordinal:
      case internal::kParent_First_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceRequest<Parent>>(
            &request_decoder, 16);
        First(std::move(arg0));
        break;
      }
      default: {
        status = ZX_ERR_NOT_SUPPORTED;
        break;
      }
    }
    return status;
  }
  virtual void First(::fidl::InterfaceRequest<Parent> request) = 0;
};

class Parent_ResponseEncoder {
 public:
};

class Parent_ResponseDecoder {
 public:
  Parent_ResponseDecoder() = default;
  virtual ~Parent_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  zx_status_t Decode_(::fidl::Message response) {
    const fidl_type_t* response_type = GetType(response.ordinal());
    if (response_type == nullptr) {
      return ZX_ERR_NOT_SUPPORTED;
    }
    const char* error_msg = nullptr;
    zx_status_t status = response.Decode(response_type, &error_msg);
    if (status != ZX_OK) {
      FIDL_REPORT_DECODING_ERROR(response, response_type, error_msg);
      return status;
    }
    ::fidl::Decoder response_decoder(std::move(response));
    switch (response.ordinal()) {
      default: {
        break;
      }
    }
    return ZX_OK;
  }
};

class Parent_EventSender {
 public:
  virtual ~Parent_EventSender();
};

class Parent_Sync {
 public:
  using Proxy_ = Parent_SyncProxy;
  virtual ~Parent_Sync();
  virtual zx_status_t First(::fidl::InterfaceRequest<Parent> request) = 0;
};

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

  zx_status_t Dispatch_(::fidl::Message message) override;
  void First(::fidl::InterfaceRequest<Parent> request) override;

 private:
  Parent_Proxy(const Parent_Proxy&) = delete;
  Parent_Proxy& operator=(const Parent_Proxy&) = delete;

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

class Parent_Stub final : public ::fidl::internal::Stub,
                          public Parent_EventSender {
 public:
  typedef class ::fidl::test::json::Parent Parent_clazz;
  explicit Parent_Stub(Parent_clazz* impl);
  ~Parent_Stub() override;

  zx_status_t Dispatch_(::fidl::Message message,
                        ::fidl::internal::PendingResponse response) override;

 private:
  Parent_clazz* impl_;
};

class Parent_SyncProxy : public Parent_Sync {
 public:
  explicit Parent_SyncProxy(::zx::channel channel);
  ~Parent_SyncProxy() override;
  zx_status_t First(::fidl::InterfaceRequest<Parent> request) override;

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

class Child {
 public:
  using Proxy_ = Child_Proxy;
  using Stub_ = Child_Stub;
  using EventSender_ = Child_EventSender;
  using Sync_ = Child_Sync;
  virtual ~Child();

  virtual void First(::fidl::InterfaceRequest<Parent> request) = 0;

  virtual void Second(::fidl::InterfaceRequest<Parent> request) = 0;
};

class Child_RequestEncoder {
 public:
  static ::fidl::Message First(::fidl::Encoder* _encoder,
                               ::fidl::InterfaceRequest<Parent>* request) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, request, 16);
    return _encoder->GetMessage();
  }
  static ::fidl::Message Second(::fidl::Encoder* _encoder,
                                ::fidl::InterfaceRequest<Parent>* request) {
    _encoder->Alloc(24 - sizeof(fidl_message_header_t));
    ::fidl::Encode(_encoder, request, 16);
    return _encoder->GetMessage();
  }
};

class Child_RequestDecoder {
 public:
  Child_RequestDecoder() = default;
  virtual ~Child_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response);
  zx_status_t Decode_(::fidl::Message request) {
    bool needs_response;
    const fidl_type_t* request_type =
        GetType(request.ordinal(), &needs_response);
    if (request_type == nullptr) {
      return ZX_ERR_NOT_SUPPORTED;
    }
    const char* error_msg = nullptr;
    zx_status_t status = request.Decode(request_type, &error_msg);
    if (status != ZX_OK) {
      FIDL_REPORT_DECODING_ERROR(request, request_type, error_msg);
      return status;
    }
    ::fidl::Decoder request_decoder(std::move(request));
    switch (request.ordinal()) {
      case internal::kChild_First_Ordinal:
      case internal::kChild_First_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceRequest<Parent>>(
            &request_decoder, 16);
        First(std::move(arg0));
        break;
      }
      case internal::kChild_Second_Ordinal:
      case internal::kChild_Second_GenOrdinal: {
        auto arg0 = ::fidl::DecodeAs<::fidl::InterfaceRequest<Parent>>(
            &request_decoder, 16);
        Second(std::move(arg0));
        break;
      }
      default: {
        status = ZX_ERR_NOT_SUPPORTED;
        break;
      }
    }
    return status;
  }
  virtual void First(::fidl::InterfaceRequest<Parent> request) = 0;
  virtual void Second(::fidl::InterfaceRequest<Parent> request) = 0;
};

class Child_ResponseEncoder {
 public:
};

class Child_ResponseDecoder {
 public:
  Child_ResponseDecoder() = default;
  virtual ~Child_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  zx_status_t Decode_(::fidl::Message response) {
    const fidl_type_t* response_type = GetType(response.ordinal());
    if (response_type == nullptr) {
      return ZX_ERR_NOT_SUPPORTED;
    }
    const char* error_msg = nullptr;
    zx_status_t status = response.Decode(response_type, &error_msg);
    if (status != ZX_OK) {
      FIDL_REPORT_DECODING_ERROR(response, response_type, error_msg);
      return status;
    }
    ::fidl::Decoder response_decoder(std::move(response));
    switch (response.ordinal()) {
      default: {
        break;
      }
    }
    return ZX_OK;
  }
};

class Child_EventSender {
 public:
  virtual ~Child_EventSender();
};

class Child_Sync {
 public:
  using Proxy_ = Child_SyncProxy;
  virtual ~Child_Sync();
  virtual zx_status_t First(::fidl::InterfaceRequest<Parent> request) = 0;
  virtual zx_status_t Second(::fidl::InterfaceRequest<Parent> request) = 0;
};

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

  zx_status_t Dispatch_(::fidl::Message message) override;
  void First(::fidl::InterfaceRequest<Parent> request) override;
  void Second(::fidl::InterfaceRequest<Parent> request) override;

 private:
  Child_Proxy(const Child_Proxy&) = delete;
  Child_Proxy& operator=(const Child_Proxy&) = delete;

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

class Child_Stub final : public ::fidl::internal::Stub,
                         public Child_EventSender {
 public:
  typedef class ::fidl::test::json::Child Child_clazz;
  explicit Child_Stub(Child_clazz* impl);
  ~Child_Stub() override;

  zx_status_t Dispatch_(::fidl::Message message,
                        ::fidl::internal::PendingResponse response) override;

 private:
  Child_clazz* impl_;
};

class Child_SyncProxy : public Child_Sync {
 public:
  explicit Child_SyncProxy(::zx::channel channel);
  ~Child_SyncProxy() override;
  zx_status_t First(::fidl::InterfaceRequest<Parent> request) override;
  zx_status_t Second(::fidl::InterfaceRequest<Parent> request) override;

 private:
  ::fidl::internal::SynchronousProxy proxy_;
  friend class ::fidl::SynchronousInterfacePtr<Child>;
};
#endif  // __Fuchsia__
}  // namespace json
}  // namespace test
}  // namespace fidl
namespace fidl {}  // namespace fidl