tools/fidl/fidlgen_cpp/goldens/unknown_interactions_natural_messaging.h.golden

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

// fidl_experiment = output_index_json

#pragma once

#include <fidl/test.unknowninteractions/cpp/markers.h>
#include <fidl/test.unknowninteractions/cpp/natural_types.h>
#include <fidl/test.unknowninteractions/cpp/wire_messaging.h>
#include <lib/fidl/cpp/channel.h>
#include <lib/fidl/cpp/client.h>
#include <lib/fidl/cpp/internal/thenable.h>
#include <lib/fidl/cpp/natural_types.h>
#include <lib/fidl/cpp/unified_messaging.h>
#include <lib/fidl/cpp/wire/unknown_interaction_handler.h>

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

namespace fidl {

}  // namespace fidl

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictOneWay> {
  using Completer = fidl::Completer<>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleOneWay> {
  using Completer = fidl::Completer<>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEvent> {
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventFields> {
  using Request = ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventUnion> {
  using Request = ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventTable> {
  using Request = ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEvent> {
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventFields> {
  using Request = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventUnion> {
  using Request = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventTable> {
  using Request = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest;
};

#ifdef __Fuchsia__

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay> final {
 public:
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay> final : public ::fit::result<::fidl::Error> {
 public:
  using ::fit::result<::fidl::Error>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields> final : public ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse::UnknownInteractionsProtocolStrictTwoWayFieldsResponse;
  Response(::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse v) : UnknownInteractionsProtocolStrictTwoWayFieldsResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion> final : public ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::UnknownInteractionsProtocolStrictTwoWayUnionResponse;
  Response(::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse v) : UnknownInteractionsProtocolStrictTwoWayUnionResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable> final : public ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse::UnknownInteractionsProtocolStrictTwoWayTableResponse;
  Response(::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse v) : UnknownInteractionsProtocolStrictTwoWayTableResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> final : public ::fit::result<int32_t> {
 public:
  using ::fit::result<int32_t>::result;
  Response(::fit::result<int32_t> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse({});
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> final {
 public:
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayResult;

 public:
  static DomainObject IntoDomainObject() {
    return DomainObject::WithResponse({});
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> final : public ::fit::result<::fidl::Error> {
 public:
  using ::fit::result<::fidl::Error>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> final : public ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse;
  Response(::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse v) : UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse(std::move(v)) {}
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields>& m) {
    return DomainObject::WithResponse(std::move(m));
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> final : public ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse;
  Response(::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse v) : UnknownInteractionsProtocolFlexibleTwoWayUnionResponse(std::move(v)) {}
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion>& m) {
    return DomainObject::WithResponse(std::move(m));
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> final : public ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse::UnknownInteractionsProtocolFlexibleTwoWayTableResponse;
  Response(::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse v) : UnknownInteractionsProtocolFlexibleTwoWayTableResponse(std::move(v)) {}
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable>& m) {
    return DomainObject::WithResponse(std::move(m));
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> final : public ::fit::result<int32_t> {
 public:
  using ::fit::result<int32_t>::result;
  Response(::fit::result<int32_t> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse({});
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsProtocol> final : public ::fidl::internal::NaturalClientBase {
 public:
  using NaturalClientBase::NaturalClientBase;
  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay> StrictTwoWay() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields> StrictTwoWayFields() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion> StrictTwoWayUnion() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable> StrictTwoWayTable() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> StrictTwoWayErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> StrictTwoWayFieldsErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> StrictTwoWayUnionErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> StrictTwoWayTableErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> FlexibleTwoWay() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> FlexibleTwoWayFields() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> FlexibleTwoWayUnion() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> FlexibleTwoWayTable() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> FlexibleTwoWayErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> FlexibleTwoWayFieldsErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> FlexibleTwoWayUnionErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> FlexibleTwoWayTableErr() const;

  ::fit::result<::fidl::OneWayError> StrictOneWay() const;

  ::fit::result<::fidl::OneWayError> FlexibleOneWay() const;
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalSyncClientImpl<::test_unknowninteractions::UnknownInteractionsProtocol> final
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalSyncClientImpl<::test_unknowninteractions::UnknownInteractionsProtocol>> {
 public:
  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay> StrictTwoWay();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields> StrictTwoWayFields();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion> StrictTwoWayUnion();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable> StrictTwoWayTable();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> StrictTwoWayErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> StrictTwoWayFieldsErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> StrictTwoWayUnionErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> StrictTwoWayTableErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> FlexibleTwoWay();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> FlexibleTwoWayFields();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> FlexibleTwoWayUnion();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> FlexibleTwoWayTable();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> FlexibleTwoWayErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> FlexibleTwoWayFieldsErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> FlexibleTwoWayUnionErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> FlexibleTwoWayTableErr();

  ::fit::result<::fidl::OneWayError> StrictOneWay();

  ::fit::result<::fidl::OneWayError> FlexibleOneWay();

 private:
  ::fidl::UnownedClientEnd<::test_unknowninteractions::UnknownInteractionsProtocol> _client_end() const {
    return ::fidl::UnownedClientEnd<::test_unknowninteractions::UnknownInteractionsProtocol>(
        _transport().get<::fidl::internal::ChannelTransport>());
  }
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsProtocol> : public ::fidl::internal::BaseEventHandlerInterface, public ::fidl::UnknownEventHandler<::test_unknowninteractions::UnknownInteractionsProtocol> {
 public:
  NaturalEventHandlerInterface() = default;
  virtual ~NaturalEventHandlerInterface() = default;
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventFields>&) = 0;
  virtual void StrictEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventUnion>&) = 0;
  virtual void StrictEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventTable>&) = 0;
  virtual void FlexibleEvent() = 0;
  virtual void FlexibleEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventFields>&) = 0;
  virtual void FlexibleEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventUnion>&) = 0;
  virtual void FlexibleEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventTable>&) = 0;
};

template <>
class ::fidl::AsyncEventHandler<::test_unknowninteractions::UnknownInteractionsProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsProtocol>, public ::fidl::internal::AsyncEventHandler {
 public:
  AsyncEventHandler() = default;
  void StrictEvent() override {}
  void StrictEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventFields>&) override {}
  void StrictEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventUnion>&) override {}
  void StrictEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::StrictEventTable>&) override {}
  void FlexibleEvent() override {}
  void FlexibleEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventFields>&) override {}
  void FlexibleEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventUnion>&) override {}
  void FlexibleEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleEventTable>&) override {}
};

template <>
class ::fidl::SyncEventHandler<::test_unknowninteractions::UnknownInteractionsProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsProtocol>, public ::fidl::internal::SyncEventHandler {
 public:
  SyncEventHandler() = default;

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

template <>
class ::fidl::internal::NaturalEventDispatcher<::test_unknowninteractions::UnknownInteractionsProtocol> final : public ::fidl::internal::IncomingEventDispatcher<::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsProtocol>> {
 public:
  explicit NaturalEventDispatcher(::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsProtocol>* event_handler)
      : IncomingEventDispatcher(event_handler) {}
  ::fidl::Status DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      internal::MessageStorageViewBase* storage_view) override;
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__
template <>
class ::fidl::internal::NaturalWeakEventSender<::test_unknowninteractions::UnknownInteractionsProtocol> : public ::fidl::internal::WeakEventSenderBase {
 public:
  using WeakEventSenderBase::WeakEventSenderBase;

  ::fit::result<::fidl::OneWayError> StrictEvent();

  ::fit::result<::fidl::OneWayError> StrictEventFields(const ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventUnion(const ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventTable(const ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEvent();

  ::fit::result<::fidl::OneWayError> FlexibleEventFields(const ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventUnion(const ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventTable(const ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& payload);
};

template <>
class ::fidl::internal::NaturalEventSender<::test_unknowninteractions::UnknownInteractionsProtocol>
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalEventSender<::test_unknowninteractions::UnknownInteractionsProtocol>> {
 public:
  using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer;

  ::fit::result<::fidl::OneWayError> StrictEvent();

  ::fit::result<::fidl::OneWayError> StrictEventFields(const ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventUnion(const ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventTable(const ::test_unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEvent();

  ::fit::result<::fidl::OneWayError> FlexibleEventFields(const ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventUnion(const ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventTable(const ::test_unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& payload);
};

#endif  // __Fuchsia__

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay> : public ::fidl::CompleterBase {
 public:
  void Reply();

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay> : public ::fidl::CompleterBase {
 public:
  void Reply();

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>& response);

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

template <>
class ::fidl::Server<::test_unknowninteractions::UnknownInteractionsProtocol> : public ::fidl::internal::IncomingMessageDispatcher, public ::fidl::UnknownMethodHandler<::test_unknowninteractions::UnknownInteractionsProtocol> {
 public:
  Server() = default;
  virtual ~Server() = default;

  // The FIDL protocol type that is implemented by this server.
  using _EnclosingProtocol = ::test_unknowninteractions::UnknownInteractionsProtocol;

  using Handler = fidl::ProtocolHandler<::test_unknowninteractions::UnknownInteractionsProtocol>;

  using StrictOneWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictOneWay>;

  virtual void StrictOneWay(
      StrictOneWayCompleter::Sync& completer) = 0;

  using FlexibleOneWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleOneWay>;

  virtual void FlexibleOneWay(
      FlexibleOneWayCompleter::Sync& completer) = 0;

  using StrictTwoWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWay>;

  virtual void StrictTwoWay(
      StrictTwoWayCompleter::Sync& completer) = 0;

  using StrictTwoWayFieldsCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFields>;

  virtual void StrictTwoWayFields(
      StrictTwoWayFieldsCompleter::Sync& completer) = 0;

  using StrictTwoWayUnionCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnion>;

  virtual void StrictTwoWayUnion(
      StrictTwoWayUnionCompleter::Sync& completer) = 0;

  using StrictTwoWayTableCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTable>;

  virtual void StrictTwoWayTable(
      StrictTwoWayTableCompleter::Sync& completer) = 0;

  using StrictTwoWayErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayErr>;

  virtual void StrictTwoWayErr(
      StrictTwoWayErrCompleter::Sync& completer) = 0;

  using StrictTwoWayFieldsErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayFieldsErr>;

  virtual void StrictTwoWayFieldsErr(
      StrictTwoWayFieldsErrCompleter::Sync& completer) = 0;

  using StrictTwoWayUnionErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayUnionErr>;

  virtual void StrictTwoWayUnionErr(
      StrictTwoWayUnionErrCompleter::Sync& completer) = 0;

  using StrictTwoWayTableErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::StrictTwoWayTableErr>;

  virtual void StrictTwoWayTableErr(
      StrictTwoWayTableErrCompleter::Sync& completer) = 0;

  using FlexibleTwoWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWay>;

  virtual void FlexibleTwoWay(
      FlexibleTwoWayCompleter::Sync& completer) = 0;

  using FlexibleTwoWayFieldsCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFields>;

  virtual void FlexibleTwoWayFields(
      FlexibleTwoWayFieldsCompleter::Sync& completer) = 0;

  using FlexibleTwoWayUnionCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnion>;

  virtual void FlexibleTwoWayUnion(
      FlexibleTwoWayUnionCompleter::Sync& completer) = 0;

  using FlexibleTwoWayTableCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTable>;

  virtual void FlexibleTwoWayTable(
      FlexibleTwoWayTableCompleter::Sync& completer) = 0;

  using FlexibleTwoWayErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayErr>;

  virtual void FlexibleTwoWayErr(
      FlexibleTwoWayErrCompleter::Sync& completer) = 0;

  using FlexibleTwoWayFieldsErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>;

  virtual void FlexibleTwoWayFieldsErr(
      FlexibleTwoWayFieldsErrCompleter::Sync& completer) = 0;

  using FlexibleTwoWayUnionErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayUnionErr>;

  virtual void FlexibleTwoWayUnionErr(
      FlexibleTwoWayUnionErrCompleter::Sync& completer) = 0;

  using FlexibleTwoWayTableErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsProtocol::FlexibleTwoWayTableErr>;

  virtual void FlexibleTwoWayTableErr(
      FlexibleTwoWayTableErrCompleter::Sync& completer) = 0;

  // |bind_handler| returns a handler that binds incoming connections to this
  // server implementation.
  //
  // The returned handler borrows the server instance.
  // The server must outlive the provided |dispatcher|. Only after
  // the dispatcher is shutdown will it be safe to destroy the servers.
  // The server should not be moved.
  Handler bind_handler(async_dispatcher_t* dispatcher) {
    return [impl = this, dispatcher = dispatcher](::fidl::ServerEnd<::test_unknowninteractions::UnknownInteractionsProtocol> request) {
      (void)::fidl::BindServer(dispatcher, std::move(request), impl);
    };
  }

 private:
  void dispatch_message(
      ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
      ::fidl::internal::MessageStorageViewBase* storage_view) final;
};

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsProtocol> final {
  NaturalServerDispatcher() = delete;
  static void Dispatch(::fidl::Server<::test_unknowninteractions::UnknownInteractionsProtocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
                       internal::MessageStorageViewBase* storage_view,
                       ::fidl::Transaction* txn);

 private:
  static const ::fidl::internal::MethodEntry entries_[];
  static const ::fidl::internal::MethodEntry* entries_end_;
  static const ::fidl::internal::UnknownMethodHandlerEntry unknown_method_handler_entry_;
};

#endif  // __Fuchsia__

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictOneWay> {
  using Completer = fidl::Completer<>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleOneWay> {
  using Completer = fidl::Completer<>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEvent> {
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventFields> {
  using Request = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventUnion> {
  using Request = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventTable> {
  using Request = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEvent> {
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventFields> {
  using Request = ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventUnion> {
  using Request = ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventTable> {
  using Request = ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest;
};

#ifdef __Fuchsia__

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay> final {
 public:
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay> final : public ::fit::result<::fidl::Error> {
 public:
  using ::fit::result<::fidl::Error>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields> final : public ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse;
  Response(::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse v) : UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion> final : public ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse;
  Response(::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse v) : UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable> final : public ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse;
  Response(::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse v) : UnknownInteractionsAjarProtocolStrictTwoWayTableResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> final : public ::fit::result<int32_t> {
 public:
  using ::fit::result<int32_t>::result;
  Response(::fit::result<int32_t> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse({});
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsAjarProtocol> final : public ::fidl::internal::NaturalClientBase {
 public:
  using NaturalClientBase::NaturalClientBase;
  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay> StrictTwoWay() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields> StrictTwoWayFields() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion> StrictTwoWayUnion() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable> StrictTwoWayTable() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> StrictTwoWayErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> StrictTwoWayFieldsErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> StrictTwoWayUnionErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> StrictTwoWayTableErr() const;

  ::fit::result<::fidl::OneWayError> StrictOneWay() const;

  ::fit::result<::fidl::OneWayError> FlexibleOneWay() const;
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalSyncClientImpl<::test_unknowninteractions::UnknownInteractionsAjarProtocol> final
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalSyncClientImpl<::test_unknowninteractions::UnknownInteractionsAjarProtocol>> {
 public:
  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay> StrictTwoWay();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields> StrictTwoWayFields();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion> StrictTwoWayUnion();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable> StrictTwoWayTable();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> StrictTwoWayErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> StrictTwoWayFieldsErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> StrictTwoWayUnionErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> StrictTwoWayTableErr();

  ::fit::result<::fidl::OneWayError> StrictOneWay();

  ::fit::result<::fidl::OneWayError> FlexibleOneWay();

 private:
  ::fidl::UnownedClientEnd<::test_unknowninteractions::UnknownInteractionsAjarProtocol> _client_end() const {
    return ::fidl::UnownedClientEnd<::test_unknowninteractions::UnknownInteractionsAjarProtocol>(
        _transport().get<::fidl::internal::ChannelTransport>());
  }
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsAjarProtocol> : public ::fidl::internal::BaseEventHandlerInterface, public ::fidl::UnknownEventHandler<::test_unknowninteractions::UnknownInteractionsAjarProtocol> {
 public:
  NaturalEventHandlerInterface() = default;
  virtual ~NaturalEventHandlerInterface() = default;
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventFields>&) = 0;
  virtual void StrictEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventUnion>&) = 0;
  virtual void StrictEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventTable>&) = 0;
  virtual void FlexibleEvent() = 0;
  virtual void FlexibleEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventFields>&) = 0;
  virtual void FlexibleEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventUnion>&) = 0;
  virtual void FlexibleEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventTable>&) = 0;
};

template <>
class ::fidl::AsyncEventHandler<::test_unknowninteractions::UnknownInteractionsAjarProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsAjarProtocol>, public ::fidl::internal::AsyncEventHandler {
 public:
  AsyncEventHandler() = default;
  void StrictEvent() override {}
  void StrictEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventFields>&) override {}
  void StrictEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventUnion>&) override {}
  void StrictEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictEventTable>&) override {}
  void FlexibleEvent() override {}
  void FlexibleEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventFields>&) override {}
  void FlexibleEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventUnion>&) override {}
  void FlexibleEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleEventTable>&) override {}
};

template <>
class ::fidl::SyncEventHandler<::test_unknowninteractions::UnknownInteractionsAjarProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsAjarProtocol>, public ::fidl::internal::SyncEventHandler {
 public:
  SyncEventHandler() = default;

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

template <>
class ::fidl::internal::NaturalEventDispatcher<::test_unknowninteractions::UnknownInteractionsAjarProtocol> final : public ::fidl::internal::IncomingEventDispatcher<::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsAjarProtocol>> {
 public:
  explicit NaturalEventDispatcher(::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsAjarProtocol>* event_handler)
      : IncomingEventDispatcher(event_handler) {}
  ::fidl::Status DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      internal::MessageStorageViewBase* storage_view) override;
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__
template <>
class ::fidl::internal::NaturalWeakEventSender<::test_unknowninteractions::UnknownInteractionsAjarProtocol> : public ::fidl::internal::WeakEventSenderBase {
 public:
  using WeakEventSenderBase::WeakEventSenderBase;

  ::fit::result<::fidl::OneWayError> StrictEvent();

  ::fit::result<::fidl::OneWayError> StrictEventFields(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventUnion(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventTable(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEvent();

  ::fit::result<::fidl::OneWayError> FlexibleEventFields(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventUnion(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventTable(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& payload);
};

template <>
class ::fidl::internal::NaturalEventSender<::test_unknowninteractions::UnknownInteractionsAjarProtocol>
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalEventSender<::test_unknowninteractions::UnknownInteractionsAjarProtocol>> {
 public:
  using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer;

  ::fit::result<::fidl::OneWayError> StrictEvent();

  ::fit::result<::fidl::OneWayError> StrictEventFields(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventUnion(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventTable(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEvent();

  ::fit::result<::fidl::OneWayError> FlexibleEventFields(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventUnion(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> FlexibleEventTable(const ::test_unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& payload);
};

#endif  // __Fuchsia__

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay> : public ::fidl::CompleterBase {
 public:
  void Reply();

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>& response);

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

template <>
class ::fidl::Server<::test_unknowninteractions::UnknownInteractionsAjarProtocol> : public ::fidl::internal::IncomingMessageDispatcher, public ::fidl::UnknownMethodHandler<::test_unknowninteractions::UnknownInteractionsAjarProtocol> {
 public:
  Server() = default;
  virtual ~Server() = default;

  // The FIDL protocol type that is implemented by this server.
  using _EnclosingProtocol = ::test_unknowninteractions::UnknownInteractionsAjarProtocol;

  using Handler = fidl::ProtocolHandler<::test_unknowninteractions::UnknownInteractionsAjarProtocol>;

  using StrictOneWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictOneWay>;

  virtual void StrictOneWay(
      StrictOneWayCompleter::Sync& completer) = 0;

  using FlexibleOneWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::FlexibleOneWay>;

  virtual void FlexibleOneWay(
      FlexibleOneWayCompleter::Sync& completer) = 0;

  using StrictTwoWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWay>;

  virtual void StrictTwoWay(
      StrictTwoWayCompleter::Sync& completer) = 0;

  using StrictTwoWayFieldsCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFields>;

  virtual void StrictTwoWayFields(
      StrictTwoWayFieldsCompleter::Sync& completer) = 0;

  using StrictTwoWayUnionCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnion>;

  virtual void StrictTwoWayUnion(
      StrictTwoWayUnionCompleter::Sync& completer) = 0;

  using StrictTwoWayTableCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTable>;

  virtual void StrictTwoWayTable(
      StrictTwoWayTableCompleter::Sync& completer) = 0;

  using StrictTwoWayErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayErr>;

  virtual void StrictTwoWayErr(
      StrictTwoWayErrCompleter::Sync& completer) = 0;

  using StrictTwoWayFieldsErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayFieldsErr>;

  virtual void StrictTwoWayFieldsErr(
      StrictTwoWayFieldsErrCompleter::Sync& completer) = 0;

  using StrictTwoWayUnionErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayUnionErr>;

  virtual void StrictTwoWayUnionErr(
      StrictTwoWayUnionErrCompleter::Sync& completer) = 0;

  using StrictTwoWayTableErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsAjarProtocol::StrictTwoWayTableErr>;

  virtual void StrictTwoWayTableErr(
      StrictTwoWayTableErrCompleter::Sync& completer) = 0;

  // |bind_handler| returns a handler that binds incoming connections to this
  // server implementation.
  //
  // The returned handler borrows the server instance.
  // The server must outlive the provided |dispatcher|. Only after
  // the dispatcher is shutdown will it be safe to destroy the servers.
  // The server should not be moved.
  Handler bind_handler(async_dispatcher_t* dispatcher) {
    return [impl = this, dispatcher = dispatcher](::fidl::ServerEnd<::test_unknowninteractions::UnknownInteractionsAjarProtocol> request) {
      (void)::fidl::BindServer(dispatcher, std::move(request), impl);
    };
  }

 private:
  void dispatch_message(
      ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
      ::fidl::internal::MessageStorageViewBase* storage_view) final;
};

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsAjarProtocol> final {
  NaturalServerDispatcher() = delete;
  static void Dispatch(::fidl::Server<::test_unknowninteractions::UnknownInteractionsAjarProtocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
                       internal::MessageStorageViewBase* storage_view,
                       ::fidl::Transaction* txn);

 private:
  static const ::fidl::internal::MethodEntry entries_[];
  static const ::fidl::internal::MethodEntry* entries_end_;
  static const ::fidl::internal::UnknownMethodHandlerEntry unknown_method_handler_entry_;
};

#endif  // __Fuchsia__

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictOneWay> {
  using Completer = fidl::Completer<>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> {
  using Response = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult;

  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>>;
  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>&)>;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEvent> {
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventFields> {
  using Request = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventUnion> {
  using Request = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventTable> {
  using Request = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest;
};

#ifdef __Fuchsia__

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay> final {
 public:
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay> final : public ::fit::result<::fidl::Error> {
 public:
  using ::fit::result<::fidl::Error>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields> final : public ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse;
  Response(::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse v) : UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion> final : public ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse;
  Response(::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse v) : UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable> final : public ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse {
 public:
  using ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse;
  Response(::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse v) : UnknownInteractionsClosedProtocolStrictTwoWayTableResponse(std::move(v)) {}
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable> final : public ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> {
 public:
  using ::fit::result<::fidl::Error, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> final : public ::fit::result<int32_t> {
 public:
  using ::fit::result<int32_t>::result;
  Response(::fit::result<int32_t> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse({});
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> final : public ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse> {
 public:
  using ::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse>::result;
  Response(::fit::result<int32_t, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse> v) : result(std::move(v)) {}
  Response() = delete;
};
template <>
class ::fidl::internal::ResponseMessageConverter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> {
  using DomainObject = ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult;

 public:
  static DomainObject IntoDomainObject(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>& m) {
    if (m.is_error()) {
      return DomainObject::WithErr(m.error_value());
    } else {
      return DomainObject::WithResponse(std::move(m.value()));
    }
  }
};

template <>
class ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> final : public ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse> {
 public:
  using ::fit::result<::fidl::ErrorsIn<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>, ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::internal::NaturalClientImpl<::test_unknowninteractions::UnknownInteractionsClosedProtocol> final : public ::fidl::internal::NaturalClientBase {
 public:
  using NaturalClientBase::NaturalClientBase;
  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay> StrictTwoWay() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields> StrictTwoWayFields() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion> StrictTwoWayUnion() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable> StrictTwoWayTable() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> StrictTwoWayErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> StrictTwoWayFieldsErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> StrictTwoWayUnionErr() const;

  ::fidl::internal::NaturalThenable<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> StrictTwoWayTableErr() const;

  ::fit::result<::fidl::OneWayError> StrictOneWay() const;
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalSyncClientImpl<::test_unknowninteractions::UnknownInteractionsClosedProtocol> final
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalSyncClientImpl<::test_unknowninteractions::UnknownInteractionsClosedProtocol>> {
 public:
  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay> StrictTwoWay();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields> StrictTwoWayFields();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion> StrictTwoWayUnion();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable> StrictTwoWayTable();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> StrictTwoWayErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> StrictTwoWayFieldsErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> StrictTwoWayUnionErr();

  ::fidl::Result<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> StrictTwoWayTableErr();

  ::fit::result<::fidl::OneWayError> StrictOneWay();

 private:
  ::fidl::UnownedClientEnd<::test_unknowninteractions::UnknownInteractionsClosedProtocol> _client_end() const {
    return ::fidl::UnownedClientEnd<::test_unknowninteractions::UnknownInteractionsClosedProtocol>(
        _transport().get<::fidl::internal::ChannelTransport>());
  }
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsClosedProtocol> : public ::fidl::internal::BaseEventHandlerInterface {
 public:
  NaturalEventHandlerInterface() = default;
  virtual ~NaturalEventHandlerInterface() = default;
  virtual void StrictEvent() = 0;
  virtual void StrictEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventFields>&) = 0;
  virtual void StrictEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventUnion>&) = 0;
  virtual void StrictEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventTable>&) = 0;
};

template <>
class ::fidl::AsyncEventHandler<::test_unknowninteractions::UnknownInteractionsClosedProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsClosedProtocol>, public ::fidl::internal::AsyncEventHandler {
 public:
  AsyncEventHandler() = default;
  void StrictEvent() override {}
  void StrictEventFields(::fidl::Event<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventFields>&) override {}
  void StrictEventUnion(::fidl::Event<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventUnion>&) override {}
  void StrictEventTable(::fidl::Event<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictEventTable>&) override {}
};

template <>
class ::fidl::SyncEventHandler<::test_unknowninteractions::UnknownInteractionsClosedProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsClosedProtocol>, public ::fidl::internal::SyncEventHandler {
 public:
  SyncEventHandler() = default;

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

template <>
class ::fidl::internal::NaturalEventDispatcher<::test_unknowninteractions::UnknownInteractionsClosedProtocol> final : public ::fidl::internal::IncomingEventDispatcher<::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsClosedProtocol>> {
 public:
  explicit NaturalEventDispatcher(::fidl::internal::NaturalEventHandlerInterface<::test_unknowninteractions::UnknownInteractionsClosedProtocol>* event_handler)
      : IncomingEventDispatcher(event_handler) {}
  ::fidl::Status DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      internal::MessageStorageViewBase* storage_view) override;
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__
template <>
class ::fidl::internal::NaturalWeakEventSender<::test_unknowninteractions::UnknownInteractionsClosedProtocol> : public ::fidl::internal::WeakEventSenderBase {
 public:
  using WeakEventSenderBase::WeakEventSenderBase;

  ::fit::result<::fidl::OneWayError> StrictEvent();

  ::fit::result<::fidl::OneWayError> StrictEventFields(const ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventUnion(const ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventTable(const ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& payload);
};

template <>
class ::fidl::internal::NaturalEventSender<::test_unknowninteractions::UnknownInteractionsClosedProtocol>
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalEventSender<::test_unknowninteractions::UnknownInteractionsClosedProtocol>> {
 public:
  using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer;

  ::fit::result<::fidl::OneWayError> StrictEvent();

  ::fit::result<::fidl::OneWayError> StrictEventFields(const ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventUnion(const ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest& payload);

  ::fit::result<::fidl::OneWayError> StrictEventTable(const ::test_unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& payload);
};

#endif  // __Fuchsia__

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay> : public ::fidl::CompleterBase {
 public:
  void Reply();

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>& response);

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

template <>
class ::fidl::internal::NaturalCompleterBase<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr> : public ::fidl::CompleterBase {
 public:
  void Reply(const ::fidl::Response<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>& response);

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

template <>
class ::fidl::Server<::test_unknowninteractions::UnknownInteractionsClosedProtocol> : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  Server() = default;
  virtual ~Server() = default;

  // The FIDL protocol type that is implemented by this server.
  using _EnclosingProtocol = ::test_unknowninteractions::UnknownInteractionsClosedProtocol;

  using Handler = fidl::ProtocolHandler<::test_unknowninteractions::UnknownInteractionsClosedProtocol>;

  using StrictOneWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictOneWay>;

  virtual void StrictOneWay(
      StrictOneWayCompleter::Sync& completer) = 0;

  using StrictTwoWayCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWay>;

  virtual void StrictTwoWay(
      StrictTwoWayCompleter::Sync& completer) = 0;

  using StrictTwoWayFieldsCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFields>;

  virtual void StrictTwoWayFields(
      StrictTwoWayFieldsCompleter::Sync& completer) = 0;

  using StrictTwoWayUnionCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnion>;

  virtual void StrictTwoWayUnion(
      StrictTwoWayUnionCompleter::Sync& completer) = 0;

  using StrictTwoWayTableCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTable>;

  virtual void StrictTwoWayTable(
      StrictTwoWayTableCompleter::Sync& completer) = 0;

  using StrictTwoWayErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayErr>;

  virtual void StrictTwoWayErr(
      StrictTwoWayErrCompleter::Sync& completer) = 0;

  using StrictTwoWayFieldsErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayFieldsErr>;

  virtual void StrictTwoWayFieldsErr(
      StrictTwoWayFieldsErrCompleter::Sync& completer) = 0;

  using StrictTwoWayUnionErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayUnionErr>;

  virtual void StrictTwoWayUnionErr(
      StrictTwoWayUnionErrCompleter::Sync& completer) = 0;

  using StrictTwoWayTableErrCompleter = ::fidl::internal::NaturalCompleter<::test_unknowninteractions::UnknownInteractionsClosedProtocol::StrictTwoWayTableErr>;

  virtual void StrictTwoWayTableErr(
      StrictTwoWayTableErrCompleter::Sync& completer) = 0;

  // |bind_handler| returns a handler that binds incoming connections to this
  // server implementation.
  //
  // The returned handler borrows the server instance.
  // The server must outlive the provided |dispatcher|. Only after
  // the dispatcher is shutdown will it be safe to destroy the servers.
  // The server should not be moved.
  Handler bind_handler(async_dispatcher_t* dispatcher) {
    return [impl = this, dispatcher = dispatcher](::fidl::ServerEnd<::test_unknowninteractions::UnknownInteractionsClosedProtocol> request) {
      (void)::fidl::BindServer(dispatcher, std::move(request), impl);
    };
  }

 private:
  void dispatch_message(
      ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
      ::fidl::internal::MessageStorageViewBase* storage_view) final;
};

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::NaturalServerDispatcher<::test_unknowninteractions::UnknownInteractionsClosedProtocol> final {
  NaturalServerDispatcher() = delete;
  static void Dispatch(::fidl::Server<::test_unknowninteractions::UnknownInteractionsClosedProtocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
                       internal::MessageStorageViewBase* storage_view,
                       ::fidl::Transaction* txn);

 private:
  static const ::fidl::internal::MethodEntry entries_[];
  static const ::fidl::internal::MethodEntry* entries_end_;
  static constexpr const ::fidl::internal::UnknownMethodHandlerEntry& unknown_method_handler_entry_ =
      ::fidl::internal::UnknownMethodHandlerEntry::kClosedProtocolHandlerEntry;
};

#endif  // __Fuchsia__

#pragma clang diagnostic pop