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

// fidl_experiment = output_index_json

#pragma once

#include <fidl/test.inheritancewithrecursivedecl/cpp/wire.h>

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

namespace fidl {
namespace testing {

template <>
class WireTestBase<::test_inheritancewithrecursivedecl::Parent> : public ::fidl::WireServer<::test_inheritancewithrecursivedecl::Parent> {
 public:
  virtual ~WireTestBase<::test_inheritancewithrecursivedecl::Parent>() = default;
  virtual void NotImplemented_(const std::string& name, ::fidl::CompleterBase& completer) = 0;
  virtual void First(
      ::test_inheritancewithrecursivedecl::wire::ParentFirstRequest* request,
      FirstCompleter::Sync& completer) override {
    NotImplemented_("First", completer);
  }
};

template <>
class WireSyncEventHandlerTestBase<::test_inheritancewithrecursivedecl::Parent> : public ::fidl::WireSyncEventHandler<::test_inheritancewithrecursivedecl::Parent> {
 public:
  virtual ~WireSyncEventHandlerTestBase<::test_inheritancewithrecursivedecl::Parent>() = default;
  virtual void NotImplemented_(const std::string& name) = 0;
};

template <>
class WireTestBase<::test_inheritancewithrecursivedecl::Child> : public ::fidl::WireServer<::test_inheritancewithrecursivedecl::Child> {
 public:
  virtual ~WireTestBase<::test_inheritancewithrecursivedecl::Child>() = default;
  virtual void NotImplemented_(const std::string& name, ::fidl::CompleterBase& completer) = 0;
  virtual void First(
      ::test_inheritancewithrecursivedecl::wire::ParentFirstRequest* request,
      FirstCompleter::Sync& completer) override {
    NotImplemented_("First", completer);
  }
  virtual void Second(
      ::test_inheritancewithrecursivedecl::wire::ChildSecondRequest* request,
      SecondCompleter::Sync& completer) override {
    NotImplemented_("Second", completer);
  }
};

template <>
class WireSyncEventHandlerTestBase<::test_inheritancewithrecursivedecl::Child> : public ::fidl::WireSyncEventHandler<::test_inheritancewithrecursivedecl::Child> {
 public:
  virtual ~WireSyncEventHandlerTestBase<::test_inheritancewithrecursivedecl::Child>() = default;
  virtual void NotImplemented_(const std::string& name) = 0;
};
#pragma clang diagnostic pop

}  // namespace testing
}  // namespace fidl
