tools/fidl/fidlgen_llcpp/goldens/protocol_payloads_hlcpp_conversion.h.golden

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

#pragma once

#include <fidl/test.protocolpayloads.imported/cpp/hlcpp_conversion.h>
#include <fidl/test.protocolpayloads/cpp/natural_types.h>
#include <lib/fidl/cpp/hlcpp_conversion.h>
#include <lib/fidl/llcpp/internal/transport_channel.h>
#include <test/protocolpayloads/cpp/fidl.h>
namespace fidl {
namespace internal {

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

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

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

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

template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse;
  static inline ::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse Convert(::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse;
  static inline ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse Convert(::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response;
  static inline ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse;
  static inline ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse Convert(::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse;
  static inline ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse;
  static inline ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse Convert(::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnImportWithErrorRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolOnImportWithErrorRequest;
  static inline ::test::protocolpayloads::MainProtocolOnImportWithErrorRequest Convert(::test_protocolpayloads::MainProtocolOnImportWithErrorRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnImportWithErrorRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnImportWithErrorRequest;
  static inline ::test_protocolpayloads::MainProtocolOnImportWithErrorRequest Convert(::test::protocolpayloads::MainProtocolOnImportWithErrorRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_OnAnonWithError_Response;
  static inline ::test::protocolpayloads::MainProtocol_OnAnonWithError_Response Convert(::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnAnonWithError_Response> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse;
  static inline ::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse Convert(::test::protocolpayloads::MainProtocol_OnAnonWithError_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest;
  static inline ::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest Convert(::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest;
  static inline ::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest Convert(::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest;
  static inline ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest;
  static inline ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest Convert(::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse;
  static inline ::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse Convert(::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse;
  static inline ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse Convert(::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolTwoWayAnonRequest;
  static inline ::test::protocolpayloads::MainProtocolTwoWayAnonRequest Convert(::test_protocolpayloads::MainProtocolTwoWayAnonRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayAnonRequest;
  static inline ::test_protocolpayloads::MainProtocolTwoWayAnonRequest Convert(::test::protocolpayloads::MainProtocolTwoWayAnonRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOneWayAnonRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolOneWayAnonRequest;
  static inline ::test::protocolpayloads::MainProtocolOneWayAnonRequest Convert(::test_protocolpayloads::MainProtocolOneWayAnonRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOneWayAnonRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOneWayAnonRequest;
  static inline ::test_protocolpayloads::MainProtocolOneWayAnonRequest Convert(::test::protocolpayloads::MainProtocolOneWayAnonRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolOnAnonRequest;
  static inline ::test::protocolpayloads::MainProtocolOnAnonRequest Convert(::test_protocolpayloads::MainProtocolOnAnonRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnAnonRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnAnonRequest;
  static inline ::test_protocolpayloads::MainProtocolOnAnonRequest Convert(::test::protocolpayloads::MainProtocolOnAnonRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::LocalStructPayload> {
  using HLCPPType = ::test::protocolpayloads::LocalStructPayload;
  static inline ::test::protocolpayloads::LocalStructPayload Convert(::test_protocolpayloads::LocalStructPayload&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::LocalStructPayload> {
  using NaturalType = ::test_protocolpayloads::LocalStructPayload;
  static inline ::test_protocolpayloads::LocalStructPayload Convert(::test::protocolpayloads::LocalStructPayload&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse;
  static inline ::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse Convert(::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse;
  static inline ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse Convert(::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest> {
  using HLCPPType = ::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest;
  static inline ::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest Convert(::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest;
  static inline ::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest Convert(::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result;
  static inline ::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result Convert(::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult;
  static inline ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult Convert(::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result;
  static inline ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult;
  static inline ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult Convert(::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnImportWithErrorResult> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_OnImportWithError_Result;
  static inline ::test::protocolpayloads::MainProtocol_OnImportWithError_Result Convert(::test_protocolpayloads::MainProtocolOnImportWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnImportWithError_Result> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnImportWithErrorResult;
  static inline ::test_protocolpayloads::MainProtocolOnImportWithErrorResult Convert(::test::protocolpayloads::MainProtocol_OnImportWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonWithErrorResult> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_OnAnonWithError_Result;
  static inline ::test::protocolpayloads::MainProtocol_OnAnonWithError_Result Convert(::test_protocolpayloads::MainProtocolOnAnonWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnAnonWithError_Result> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult;
  static inline ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult Convert(::test::protocolpayloads::MainProtocol_OnAnonWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result;
  static inline ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result Convert(::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result> {
  using NaturalType = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult;
  static inline ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult Convert(::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnLocalWithErrorResult> {
  using HLCPPType = ::test::protocolpayloads::MainProtocol_OnLocalWithError_Result;
  static inline ::test::protocolpayloads::MainProtocol_OnLocalWithError_Result Convert(::test_protocolpayloads::MainProtocolOnLocalWithErrorResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnLocalWithError_Result> {
  using NaturalType = ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult;
  static inline ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult Convert(::test::protocolpayloads::MainProtocol_OnLocalWithError_Result&&);
};

::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse>::Convert(::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse&& value) {
  ::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse>::Convert(::test::protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}
::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse>::Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse&& value) {
  ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response>::Convert(::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse>::Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse&& value) {
  ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse>::Convert(::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}
::test::protocolpayloads::MainProtocolOnImportWithErrorRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnImportWithErrorRequest>::Convert(::test_protocolpayloads::MainProtocolOnImportWithErrorRequest&& value) {
  ::test::protocolpayloads::MainProtocolOnImportWithErrorRequest hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnImportWithErrorRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnImportWithErrorRequest>::Convert(::test::protocolpayloads::MainProtocolOnImportWithErrorRequest&& value) {
  return ::test_protocolpayloads::MainProtocolOnImportWithErrorRequest{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}
::test::protocolpayloads::MainProtocol_OnAnonWithError_Response NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse>::Convert(::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse&& value) {
  ::test::protocolpayloads::MainProtocol_OnAnonWithError_Response hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnAnonWithError_Response>::Convert(::test::protocolpayloads::MainProtocol_OnAnonWithError_Response&& value) {
  return ::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest>::Convert(::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest&& value) {
  ::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest>::Convert(::test::protocolpayloads::MainProtocolOnAnonWithErrorRequest&& value) {
  return ::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}
::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest>::Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest&& value) {
  ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest>::Convert(::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse>::Convert(::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse&& value) {
  ::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse>::Convert(::test::protocolpayloads::MainProtocolTwoWayAnonTopResponse&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolTwoWayAnonRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonRequest>::Convert(::test_protocolpayloads::MainProtocolTwoWayAnonRequest&& value) {
  ::test::protocolpayloads::MainProtocolTwoWayAnonRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayAnonRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayAnonRequest>::Convert(::test::protocolpayloads::MainProtocolTwoWayAnonRequest&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayAnonRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolOneWayAnonRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOneWayAnonRequest>::Convert(::test_protocolpayloads::MainProtocolOneWayAnonRequest&& value) {
  ::test::protocolpayloads::MainProtocolOneWayAnonRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOneWayAnonRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOneWayAnonRequest>::Convert(::test::protocolpayloads::MainProtocolOneWayAnonRequest&& value) {
  return ::test_protocolpayloads::MainProtocolOneWayAnonRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolOnAnonRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonRequest>::Convert(::test_protocolpayloads::MainProtocolOnAnonRequest&& value) {
  ::test::protocolpayloads::MainProtocolOnAnonRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnAnonRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnAnonRequest>::Convert(::test::protocolpayloads::MainProtocolOnAnonRequest&& value) {
  return ::test_protocolpayloads::MainProtocolOnAnonRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::LocalStructPayload NaturalToHLCPPTraits<::test_protocolpayloads::LocalStructPayload>::Convert(::test_protocolpayloads::LocalStructPayload&& value) {
  ::test::protocolpayloads::LocalStructPayload hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocolpayloads::LocalStructPayload HLCPPToNaturalTraits<::test::protocolpayloads::LocalStructPayload>::Convert(::test::protocolpayloads::LocalStructPayload&& value) {
  return ::test_protocolpayloads::LocalStructPayload{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse>::Convert(::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse&& value) {
  ::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse>::Convert(::test::protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse&& value) {
  return ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}
::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest>::Convert(::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest&& value) {
  ::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest>::Convert(::test::protocolpayloads::MainProtocolOnLocalWithErrorRequest&& value) {
  return ::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}

::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult>::Convert(::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult&& value) {
  ::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result>::Convert(::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result&& value) {
  using _NaturalUnion = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult;
  switch (value.Which()) {
    case ::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocolpayloads::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::protocolpayloads::MainProtocol_TwoWayImportWithError_Result");
  }
}
::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult>::Convert(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult&& value) {
  ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result>::Convert(::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result&& value) {
  using _NaturalUnion = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult;
  switch (value.Which()) {
    case ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocolpayloads::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::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result");
  }
}
::test::protocolpayloads::MainProtocol_OnImportWithError_Result NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnImportWithErrorResult>::Convert(::test_protocolpayloads::MainProtocolOnImportWithErrorResult&& value) {
  ::test::protocolpayloads::MainProtocol_OnImportWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocolpayloads::MainProtocolOnImportWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocolpayloads::MainProtocolOnImportWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnImportWithErrorResult HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnImportWithError_Result>::Convert(::test::protocolpayloads::MainProtocol_OnImportWithError_Result&& value) {
  using _NaturalUnion = ::test_protocolpayloads::MainProtocolOnImportWithErrorResult;
  switch (value.Which()) {
    case ::test::protocolpayloads::MainProtocol_OnImportWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocolpayloads::MainProtocol_OnImportWithError_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::protocolpayloads::MainProtocol_OnImportWithError_Result");
  }
}
::test::protocolpayloads::MainProtocol_OnAnonWithError_Result NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnAnonWithErrorResult>::Convert(::test_protocolpayloads::MainProtocolOnAnonWithErrorResult&& value) {
  ::test::protocolpayloads::MainProtocol_OnAnonWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnAnonWithErrorResult HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnAnonWithError_Result>::Convert(::test::protocolpayloads::MainProtocol_OnAnonWithError_Result&& value) {
  using _NaturalUnion = ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult;
  switch (value.Which()) {
    case ::test::protocolpayloads::MainProtocol_OnAnonWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocolpayloads::MainProtocol_OnAnonWithError_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::protocolpayloads::MainProtocol_OnAnonWithError_Result");
  }
}
::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult>::Convert(::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult&& value) {
  ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result>::Convert(::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result&& value) {
  using _NaturalUnion = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult;
  switch (value.Which()) {
    case ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocolpayloads::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::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result");
  }
}
::test::protocolpayloads::MainProtocol_OnLocalWithError_Result NaturalToHLCPPTraits<::test_protocolpayloads::MainProtocolOnLocalWithErrorResult>::Convert(::test_protocolpayloads::MainProtocolOnLocalWithErrorResult&& value) {
  ::test::protocolpayloads::MainProtocol_OnLocalWithError_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocolpayloads::MainProtocolOnLocalWithErrorResult HLCPPToNaturalTraits<::test::protocolpayloads::MainProtocol_OnLocalWithError_Result>::Convert(::test::protocolpayloads::MainProtocol_OnLocalWithError_Result&& value) {
  using _NaturalUnion = ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult;
  switch (value.Which()) {
    case ::test::protocolpayloads::MainProtocol_OnLocalWithError_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocolpayloads::MainProtocol_OnLocalWithError_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::protocolpayloads::MainProtocol_OnLocalWithError_Result");
  }
}

}  // namespace internal
}  // namespace fidl