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

// fidl_experiment = output_index_json

#pragma once

#include <fidl/test.protocollayoutssamelibrary/cpp/fidl.h>

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

namespace fidl {
namespace testing {

template <>
class TestBase<::test_protocollayoutssamelibrary::ComposedProtocol> : public ::fidl::Server<::test_protocollayoutssamelibrary::ComposedProtocol> {
 public:
  virtual ~TestBase<::test_protocollayoutssamelibrary::ComposedProtocol>() = default;
  virtual void NotImplemented_(const std::string& name, ::fidl::CompleterBase& completer) = 0;
  virtual void OneWayAnonComposed(OneWayAnonComposedRequest& request,
                                  OneWayAnonComposedCompleter::Sync& completer) {
    NotImplemented_("OneWayAnonComposed", completer);
  }
  virtual void TwoWayAnonComposed(TwoWayAnonComposedRequest& request,
                                  TwoWayAnonComposedCompleter::Sync& completer) {
    NotImplemented_("TwoWayAnonComposed", completer);
  }
  virtual void TwoWayAnonComposedWithError(TwoWayAnonComposedWithErrorRequest& request,
                                           TwoWayAnonComposedWithErrorCompleter::Sync& completer) {
    NotImplemented_("TwoWayAnonComposedWithError", completer);
  }
  virtual void OneWayNamedComposed(OneWayNamedComposedRequest& request,
                                   OneWayNamedComposedCompleter::Sync& completer) {
    NotImplemented_("OneWayNamedComposed", completer);
  }
  virtual void TwoWayNamedComposed(TwoWayNamedComposedRequest& request,
                                   TwoWayNamedComposedCompleter::Sync& completer) {
    NotImplemented_("TwoWayNamedComposed", completer);
  }
  virtual void TwoWayNamedComposedWithError(TwoWayNamedComposedWithErrorRequest& request,
                                            TwoWayNamedComposedWithErrorCompleter::Sync& completer) {
    NotImplemented_("TwoWayNamedComposedWithError", completer);
  }
};

template <>
class TestBase<::test_protocollayoutssamelibrary::MainProtocol> : public ::fidl::Server<::test_protocollayoutssamelibrary::MainProtocol> {
 public:
  virtual ~TestBase<::test_protocollayoutssamelibrary::MainProtocol>() = default;
  virtual void NotImplemented_(const std::string& name, ::fidl::CompleterBase& completer) = 0;
  virtual void OneWayAnonComposed(OneWayAnonComposedRequest& request,
                                  OneWayAnonComposedCompleter::Sync& completer) {
    NotImplemented_("OneWayAnonComposed", completer);
  }
  virtual void TwoWayAnonComposed(TwoWayAnonComposedRequest& request,
                                  TwoWayAnonComposedCompleter::Sync& completer) {
    NotImplemented_("TwoWayAnonComposed", completer);
  }
  virtual void TwoWayAnonComposedWithError(TwoWayAnonComposedWithErrorRequest& request,
                                           TwoWayAnonComposedWithErrorCompleter::Sync& completer) {
    NotImplemented_("TwoWayAnonComposedWithError", completer);
  }
  virtual void OneWayNamedComposed(OneWayNamedComposedRequest& request,
                                   OneWayNamedComposedCompleter::Sync& completer) {
    NotImplemented_("OneWayNamedComposed", completer);
  }
  virtual void TwoWayNamedComposed(TwoWayNamedComposedRequest& request,
                                   TwoWayNamedComposedCompleter::Sync& completer) {
    NotImplemented_("TwoWayNamedComposed", completer);
  }
  virtual void TwoWayNamedComposedWithError(TwoWayNamedComposedWithErrorRequest& request,
                                            TwoWayNamedComposedWithErrorCompleter::Sync& completer) {
    NotImplemented_("TwoWayNamedComposedWithError", completer);
  }
  virtual void OneWayLocal(OneWayLocalRequest& request,
                           OneWayLocalCompleter::Sync& completer) {
    NotImplemented_("OneWayLocal", completer);
  }
  virtual void TwoWayLocal(TwoWayLocalRequest& request,
                           TwoWayLocalCompleter::Sync& completer) {
    NotImplemented_("TwoWayLocal", completer);
  }
  virtual void TwoWayLocalWithError(TwoWayLocalWithErrorRequest& request,
                                    TwoWayLocalWithErrorCompleter::Sync& completer) {
    NotImplemented_("TwoWayLocalWithError", completer);
  }
  virtual void OneWayAnon(OneWayAnonRequest& request,
                          OneWayAnonCompleter::Sync& completer) {
    NotImplemented_("OneWayAnon", completer);
  }
  virtual void TwoWayAnon(TwoWayAnonRequest& request,
                          TwoWayAnonCompleter::Sync& completer) {
    NotImplemented_("TwoWayAnon", completer);
  }
  virtual void TwoWayAnonWithError(TwoWayAnonWithErrorRequest& request,
                                   TwoWayAnonWithErrorCompleter::Sync& completer) {
    NotImplemented_("TwoWayAnonWithError", completer);
  }
};
#pragma clang diagnostic pop

}  // namespace testing
}  // namespace fidl
