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

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

// fidl_experiment = output_index_json

#pragma once

#include <fidl/test.protocollayouts.imported/cpp/hlcpp_conversion.h>
#include <fidl/test.protocollayouts/cpp/natural_types.h>
#include <lib/fidl/cpp/hlcpp_conversion.h>
#include <lib/fidl/cpp/wire/service_handler.h>
#include <test/protocollayouts/cpp/fidl.h>

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

namespace fidl {
namespace internal {

template <>
struct NaturalToHLCPPTraits<fidl::ClientEnd<::test_protocollayouts::MainProtocol>> {
  using HLCPPType = fidl::InterfaceHandle<::test::protocollayouts::MainProtocol>;
  static inline fidl::InterfaceHandle<::test::protocollayouts::MainProtocol> Convert(fidl::ClientEnd<::test_protocollayouts::MainProtocol>&& c) {
    return fidl::InterfaceHandle<::test::protocollayouts::MainProtocol>(c.TakeChannel());
  }
};

template <>
struct NaturalToHLCPPTraits<fidl::ServerEnd<::test_protocollayouts::MainProtocol>> {
  using HLCPPType = fidl::InterfaceRequest<::test::protocollayouts::MainProtocol>;
  static inline fidl::InterfaceRequest<::test::protocollayouts::MainProtocol> Convert(fidl::ServerEnd<::test_protocollayouts::MainProtocol>&& c) {
    return fidl::InterfaceRequest<::test::protocollayouts::MainProtocol>(c.TakeChannel());
  }
};

template <>
struct HLCPPToNaturalTraits<fidl::InterfaceHandle<::test::protocollayouts::MainProtocol>> {
  using NaturalType = fidl::ClientEnd<::test_protocollayouts::MainProtocol>;
  static inline fidl::ClientEnd<::test_protocollayouts::MainProtocol> Convert(fidl::InterfaceHandle<::test::protocollayouts::MainProtocol>&& c) {
    return fidl::ClientEnd<::test_protocollayouts::MainProtocol>(c.TakeChannel());
  }
};

template <>
struct HLCPPToNaturalTraits<fidl::InterfaceRequest<::test::protocollayouts::MainProtocol>> {
  using NaturalType = fidl::ServerEnd<::test_protocollayouts::MainProtocol>;
  static inline fidl::ServerEnd<::test_protocollayouts::MainProtocol> Convert(fidl::InterfaceRequest<::test::protocollayouts::MainProtocol>&& c) {
    return fidl::ServerEnd<::test_protocollayouts::MainProtocol>(c.TakeChannel());
  }
};

template <>
struct NaturalToHLCPPTraits<fidl::ProtocolHandler<::test_protocollayouts::MainProtocol>> {
  using HLCPPType = fidl::InterfaceRequestHandler<::test::protocollayouts::MainProtocol>;
  static inline fidl::InterfaceRequestHandler<::test::protocollayouts::MainProtocol> Convert(fidl::ProtocolHandler<::test_protocollayouts::MainProtocol>&& c) {
    return [c = std::move(c)](fidl::InterfaceRequest<::test::protocollayouts::MainProtocol> r) {
      c(::fidl::HLCPPToNatural(r));
    };
  }
};

template <>
struct HLCPPToNaturalTraits<fidl::InterfaceRequestHandler<::test::protocollayouts::MainProtocol>> {
  using NaturalType = fidl::ProtocolHandler<::test_protocollayouts::MainProtocol>;
  static inline fidl::ProtocolHandler<::test_protocollayouts::MainProtocol> Convert(fidl::InterfaceRequestHandler<::test::protocollayouts::MainProtocol>&& c) {
    return [c = std::move(c)](fidl::ServerEnd<::test_protocollayouts::MainProtocol> r) {
      c(::fidl::NaturalToHLCPP(r));
    };
  }
};
template <>
struct NaturalToHLCPPTraits<fidl::ClientEnd<::test_protocollayouts::OpenProtocol>> {
  using HLCPPType = fidl::InterfaceHandle<::test::protocollayouts::OpenProtocol>;
  static inline fidl::InterfaceHandle<::test::protocollayouts::OpenProtocol> Convert(fidl::ClientEnd<::test_protocollayouts::OpenProtocol>&& c) {
    return fidl::InterfaceHandle<::test::protocollayouts::OpenProtocol>(c.TakeChannel());
  }
};

template <>
struct NaturalToHLCPPTraits<fidl::ServerEnd<::test_protocollayouts::OpenProtocol>> {
  using HLCPPType = fidl::InterfaceRequest<::test::protocollayouts::OpenProtocol>;
  static inline fidl::InterfaceRequest<::test::protocollayouts::OpenProtocol> Convert(fidl::ServerEnd<::test_protocollayouts::OpenProtocol>&& c) {
    return fidl::InterfaceRequest<::test::protocollayouts::OpenProtocol>(c.TakeChannel());
  }
};

template <>
struct HLCPPToNaturalTraits<fidl::InterfaceHandle<::test::protocollayouts::OpenProtocol>> {
  using NaturalType = fidl::ClientEnd<::test_protocollayouts::OpenProtocol>;
  static inline fidl::ClientEnd<::test_protocollayouts::OpenProtocol> Convert(fidl::InterfaceHandle<::test::protocollayouts::OpenProtocol>&& c) {
    return fidl::ClientEnd<::test_protocollayouts::OpenProtocol>(c.TakeChannel());
  }
};

template <>
struct HLCPPToNaturalTraits<fidl::InterfaceRequest<::test::protocollayouts::OpenProtocol>> {
  using NaturalType = fidl::ServerEnd<::test_protocollayouts::OpenProtocol>;
  static inline fidl::ServerEnd<::test_protocollayouts::OpenProtocol> Convert(fidl::InterfaceRequest<::test::protocollayouts::OpenProtocol>&& c) {
    return fidl::ServerEnd<::test_protocollayouts::OpenProtocol>(c.TakeChannel());
  }
};

template <>
struct NaturalToHLCPPTraits<fidl::ProtocolHandler<::test_protocollayouts::OpenProtocol>> {
  using HLCPPType = fidl::InterfaceRequestHandler<::test::protocollayouts::OpenProtocol>;
  static inline fidl::InterfaceRequestHandler<::test::protocollayouts::OpenProtocol> Convert(fidl::ProtocolHandler<::test_protocollayouts::OpenProtocol>&& c) {
    return [c = std::move(c)](fidl::InterfaceRequest<::test::protocollayouts::OpenProtocol> r) {
      c(::fidl::HLCPPToNatural(r));
    };
  }
};

template <>
struct HLCPPToNaturalTraits<fidl::InterfaceRequestHandler<::test::protocollayouts::OpenProtocol>> {
  using NaturalType = fidl::ProtocolHandler<::test_protocollayouts::OpenProtocol>;
  static inline fidl::ProtocolHandler<::test_protocollayouts::OpenProtocol> Convert(fidl::InterfaceRequestHandler<::test::protocollayouts::OpenProtocol>&& c) {
    return [c = std::move(c)](fidl::ServerEnd<::test_protocollayouts::OpenProtocol> r) {
      c(::fidl::NaturalToHLCPP(r));
    };
  }
};

template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::LocalTablePayload> {
  using HLCPPType = ::test::protocollayouts::LocalTablePayload;
  static inline ::test::protocollayouts::LocalTablePayload Convert(::test_protocollayouts::LocalTablePayload&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::LocalTablePayload> {
  using NaturalType = ::test_protocollayouts::LocalTablePayload;
  static inline ::test_protocollayouts::LocalTablePayload Convert(::test::protocollayouts::LocalTablePayload&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolOneWayAnonRequest> {
  using HLCPPType = ::test::protocollayouts::MainProtocolOneWayAnonRequest;
  static inline ::test::protocollayouts::MainProtocolOneWayAnonRequest Convert(::test_protocollayouts::MainProtocolOneWayAnonRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolOneWayAnonRequest> {
  using NaturalType = ::test_protocollayouts::MainProtocolOneWayAnonRequest;
  static inline ::test_protocollayouts::MainProtocolOneWayAnonRequest Convert(::test::protocollayouts::MainProtocolOneWayAnonRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonResponse> {
  using HLCPPType = ::test::protocollayouts::MainProtocolTwoWayAnonResponse;
  static inline ::test::protocollayouts::MainProtocolTwoWayAnonResponse Convert(::test_protocollayouts::MainProtocolTwoWayAnonResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolTwoWayAnonResponse> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayAnonResponse;
  static inline ::test_protocollayouts::MainProtocolTwoWayAnonResponse Convert(::test::protocollayouts::MainProtocolTwoWayAnonResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest> {
  using HLCPPType = ::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest;
  static inline ::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest Convert(::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest;
  static inline ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest Convert(::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::LocalUnionPayload> {
  using HLCPPType = ::test::protocollayouts::LocalUnionPayload;
  static inline ::test::protocollayouts::LocalUnionPayload Convert(::test_protocollayouts::LocalUnionPayload&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::LocalUnionPayload> {
  using NaturalType = ::test_protocollayouts::LocalUnionPayload;
  static inline ::test_protocollayouts::LocalUnionPayload Convert(::test::protocollayouts::LocalUnionPayload&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult> {
  using HLCPPType = ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result;
  static inline ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result Convert(::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult;
  static inline ::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult Convert(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult> {
  using HLCPPType = ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result;
  static inline ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result Convert(::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult;
  static inline ::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult Convert(::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonRequest> {
  using HLCPPType = ::test::protocollayouts::MainProtocolTwoWayAnonRequest;
  static inline ::test::protocollayouts::MainProtocolTwoWayAnonRequest Convert(::test_protocollayouts::MainProtocolTwoWayAnonRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolTwoWayAnonRequest> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayAnonRequest;
  static inline ::test_protocollayouts::MainProtocolTwoWayAnonRequest Convert(::test::protocollayouts::MainProtocolTwoWayAnonRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse> {
  using HLCPPType = ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response;
  static inline ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response Convert(::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse;
  static inline ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse Convert(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult> {
  using HLCPPType = ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result;
  static inline ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result Convert(::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result> {
  using NaturalType = ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult;
  static inline ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult Convert(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolOnAnonRequest> {
  using HLCPPType = ::test::protocollayouts::MainProtocolOnAnonRequest;
  static inline ::test::protocollayouts::MainProtocolOnAnonRequest Convert(::test_protocollayouts::MainProtocolOnAnonRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolOnAnonRequest> {
  using NaturalType = ::test_protocollayouts::MainProtocolOnAnonRequest;
  static inline ::test_protocollayouts::MainProtocolOnAnonRequest Convert(::test::protocollayouts::MainProtocolOnAnonRequest&&);
};

::test::protocollayouts::LocalTablePayload NaturalToHLCPPTraits<::test_protocollayouts::LocalTablePayload>::Convert(::test_protocollayouts::LocalTablePayload&& value) {
  ::test::protocollayouts::LocalTablePayload hlcpp;
  if (value.a().has_value()) {
    hlcpp.set_a(::fidl::NaturalToHLCPP(std::move(value.a().value())));
  }
  return hlcpp;
}

::test_protocollayouts::LocalTablePayload HLCPPToNaturalTraits<::test::protocollayouts::LocalTablePayload>::Convert(::test::protocollayouts::LocalTablePayload&& value) {
  ::test_protocollayouts::LocalTablePayload natural;
  if (value.has_a()) {
    natural.a() = ::fidl::HLCPPToNatural(std::move(*value.mutable_a()));
  }
  return natural;
}
::test::protocollayouts::MainProtocolOneWayAnonRequest NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolOneWayAnonRequest>::Convert(::test_protocollayouts::MainProtocolOneWayAnonRequest&& value) {
  ::test::protocollayouts::MainProtocolOneWayAnonRequest hlcpp;
  if (value.a().has_value()) {
    hlcpp.set_a(::fidl::NaturalToHLCPP(std::move(value.a().value())));
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolOneWayAnonRequest HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolOneWayAnonRequest>::Convert(::test::protocollayouts::MainProtocolOneWayAnonRequest&& value) {
  ::test_protocollayouts::MainProtocolOneWayAnonRequest natural;
  if (value.has_a()) {
    natural.a() = ::fidl::HLCPPToNatural(std::move(*value.mutable_a()));
  }
  return natural;
}
::test::protocollayouts::MainProtocolTwoWayAnonResponse NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonResponse>::Convert(::test_protocollayouts::MainProtocolTwoWayAnonResponse&& value) {
  ::test::protocollayouts::MainProtocolTwoWayAnonResponse hlcpp;
  if (value.a().has_value()) {
    hlcpp.set_a(::fidl::NaturalToHLCPP(std::move(value.a().value())));
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayAnonResponse HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolTwoWayAnonResponse>::Convert(::test::protocollayouts::MainProtocolTwoWayAnonResponse&& value) {
  ::test_protocollayouts::MainProtocolTwoWayAnonResponse natural;
  if (value.has_a()) {
    natural.a() = ::fidl::HLCPPToNatural(std::move(*value.mutable_a()));
  }
  return natural;
}
::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest>::Convert(::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest&& value) {
  ::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest hlcpp;
  if (value.a().has_value()) {
    hlcpp.set_a(::fidl::NaturalToHLCPP(std::move(value.a().value())));
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest>::Convert(::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest&& value) {
  ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorRequest natural;
  if (value.has_a()) {
    natural.a() = ::fidl::HLCPPToNatural(std::move(*value.mutable_a()));
  }
  return natural;
}

::test::protocollayouts::LocalUnionPayload NaturalToHLCPPTraits<::test_protocollayouts::LocalUnionPayload>::Convert(::test_protocollayouts::LocalUnionPayload&& value) {
  ::test::protocollayouts::LocalUnionPayload hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::LocalUnionPayload::Tag::kB:
      hlcpp.set_b(::fidl::NaturalToHLCPP(std::move(value.b().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::LocalUnionPayload HLCPPToNaturalTraits<::test::protocollayouts::LocalUnionPayload>::Convert(::test::protocollayouts::LocalUnionPayload&& value) {
  using _NaturalUnion = ::test_protocollayouts::LocalUnionPayload;
  switch (value.Which()) {
    case ::test::protocollayouts::LocalUnionPayload::Tag::kB:
      return _NaturalUnion::WithB(
          ::fidl::HLCPPToNatural(std::move(value.b())));
    default:
      return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{});
  }
}
::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult>::Convert(::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult&& value) {
  ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result>::Convert(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result&& value) {
  using _NaturalUnion = ::test_protocollayouts::MainProtocolTwoWayImportWithErrorResult;
  switch (value.Which()) {
    case ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kErr:
      return _NaturalUnion::WithErr(
          ::fidl::HLCPPToNatural(std::move(value.err())));
    default:
      ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result");
  }
}
::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult>::Convert(::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult&& value) {
  ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result>::Convert(::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result&& value) {
  using _NaturalUnion = ::test_protocollayouts::MainProtocolTwoWayLocalWithErrorResult;
  switch (value.Which()) {
    case ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr:
      return _NaturalUnion::WithErr(
          ::fidl::HLCPPToNatural(std::move(value.err())));
    default:
      ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result");
  }
}
::test::protocollayouts::MainProtocolTwoWayAnonRequest NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonRequest>::Convert(::test_protocollayouts::MainProtocolTwoWayAnonRequest&& value) {
  ::test::protocollayouts::MainProtocolTwoWayAnonRequest hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::MainProtocolTwoWayAnonRequest::Tag::kB:
      hlcpp.set_b(::fidl::NaturalToHLCPP(std::move(value.b().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayAnonRequest HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolTwoWayAnonRequest>::Convert(::test::protocollayouts::MainProtocolTwoWayAnonRequest&& value) {
  using _NaturalUnion = ::test_protocollayouts::MainProtocolTwoWayAnonRequest;
  switch (value.Which()) {
    case ::test::protocollayouts::MainProtocolTwoWayAnonRequest::Tag::kB:
      return _NaturalUnion::WithB(
          ::fidl::HLCPPToNatural(std::move(value.b())));
    default:
      return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{});
  }
}
::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse>::Convert(::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse&& value) {
  ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse::Tag::kB:
      hlcpp.set_b(::fidl::NaturalToHLCPP(std::move(value.b().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response>::Convert(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response&& value) {
  using _NaturalUnion = ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResponse;
  switch (value.Which()) {
    case ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response::Tag::kB:
      return _NaturalUnion::WithB(
          ::fidl::HLCPPToNatural(std::move(value.b())));
    default:
      return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{});
  }
}
::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult>::Convert(::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult&& value) {
  ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult HLCPPToNaturalTraits<::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result>::Convert(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result&& value) {
  using _NaturalUnion = ::test_protocollayouts::MainProtocolTwoWayAnonWithErrorResult;
  switch (value.Which()) {
    case ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kErr:
      return _NaturalUnion::WithErr(
          ::fidl::HLCPPToNatural(std::move(value.err())));
    default:
      ZX_PANIC("Can't convert invalid strict union %s from HLCPP to Natural", "::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result");
  }
}
::test::protocollayouts::MainProtocolOnAnonRequest NaturalToHLCPPTraits<::test_protocollayouts::MainProtocolOnAnonRequest>::Convert(::test_protocollayouts::MainProtocolOnAnonRequest&& value) {
  ::test::protocollayouts::MainProtocolOnAnonRequest hlcpp;
  switch (value.Which()) {
    case ::test_protocollayouts::MainProtocolOnAnonRequest::Tag::kB:
      hlcpp.set_b(::fidl::NaturalToHLCPP(std::move(value.b().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocollayouts::MainProtocolOnAnonRequest HLCPPToNaturalTraits<::test::protocollayouts::MainProtocolOnAnonRequest>::Convert(::test::protocollayouts::MainProtocolOnAnonRequest&& value) {
  using _NaturalUnion = ::test_protocollayouts::MainProtocolOnAnonRequest;
  switch (value.Which()) {
    case ::test::protocollayouts::MainProtocolOnAnonRequest::Tag::kB:
      return _NaturalUnion::WithB(
          ::fidl::HLCPPToNatural(std::move(value.b())));
    default:
      return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{});
  }
}

#pragma clang diagnostic pop

}  // namespace internal
}  // namespace fidl