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

// fidl_experiment = output_index_json

#pragma once

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

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

namespace fidl {
namespace internal {

template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Enum> : public NaturalToHLCPPTraitsEnum<::test_typesinprotocols::Enum, ::test::typesinprotocols::Enum, uint32_t> {};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Enum> : public HLCPPToNaturalTraitsEnum<::test::typesinprotocols::Enum, ::test_typesinprotocols::Enum> {};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Bits> : public NaturalToHLCPPTraitsBits<::test_typesinprotocols::Bits, ::test::typesinprotocols::Bits, uint32_t> {};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Bits> : public HLCPPToNaturalTraitsBits<::test::typesinprotocols::Bits, ::test_typesinprotocols::Bits, uint32_t> {};

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

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

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

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

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

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

template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Struct> {
  using HLCPPType = ::test::typesinprotocols::Struct;
  static inline ::test::typesinprotocols::Struct Convert(::test_typesinprotocols::Struct&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Struct> {
  using NaturalType = ::test_typesinprotocols::Struct;
  static inline ::test_typesinprotocols::Struct Convert(::test::typesinprotocols::Struct&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceStruct> {
  using HLCPPType = ::test::typesinprotocols::ResourceStruct;
  static inline ::test::typesinprotocols::ResourceStruct Convert(::test_typesinprotocols::ResourceStruct&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceStruct> {
  using NaturalType = ::test_typesinprotocols::ResourceStruct;
  static inline ::test_typesinprotocols::ResourceStruct Convert(::test::typesinprotocols::ResourceStruct&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Basic> {
  using HLCPPType = ::test::typesinprotocols::Basic;
  static inline ::test::typesinprotocols::Basic Convert(::test_typesinprotocols::Basic&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Basic> {
  using NaturalType = ::test_typesinprotocols::Basic;
  static inline ::test_typesinprotocols::Basic Convert(::test::typesinprotocols::Basic&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Compound> {
  using HLCPPType = ::test::typesinprotocols::Compound;
  static inline ::test::typesinprotocols::Compound Convert(::test_typesinprotocols::Compound&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Compound> {
  using NaturalType = ::test_typesinprotocols::Compound;
  static inline ::test_typesinprotocols::Compound Convert(::test::typesinprotocols::Compound&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ArrayBasic> {
  using HLCPPType = ::test::typesinprotocols::ArrayBasic;
  static inline ::test::typesinprotocols::ArrayBasic Convert(::test_typesinprotocols::ArrayBasic&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::ArrayBasic> {
  using NaturalType = ::test_typesinprotocols::ArrayBasic;
  static inline ::test_typesinprotocols::ArrayBasic Convert(::test::typesinprotocols::ArrayBasic&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ArrayCompound> {
  using HLCPPType = ::test::typesinprotocols::ArrayCompound;
  static inline ::test::typesinprotocols::ArrayCompound Convert(::test_typesinprotocols::ArrayCompound&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::ArrayCompound> {
  using NaturalType = ::test_typesinprotocols::ArrayCompound;
  static inline ::test_typesinprotocols::ArrayCompound Convert(::test::typesinprotocols::ArrayCompound&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::VectorBasic> {
  using HLCPPType = ::test::typesinprotocols::VectorBasic;
  static inline ::test::typesinprotocols::VectorBasic Convert(::test_typesinprotocols::VectorBasic&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::VectorBasic> {
  using NaturalType = ::test_typesinprotocols::VectorBasic;
  static inline ::test_typesinprotocols::VectorBasic Convert(::test::typesinprotocols::VectorBasic&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::VectorCompound> {
  using HLCPPType = ::test::typesinprotocols::VectorCompound;
  static inline ::test::typesinprotocols::VectorCompound Convert(::test_typesinprotocols::VectorCompound&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::VectorCompound> {
  using NaturalType = ::test_typesinprotocols::VectorCompound;
  static inline ::test_typesinprotocols::VectorCompound Convert(::test::typesinprotocols::VectorCompound&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::VectorOptional> {
  using HLCPPType = ::test::typesinprotocols::VectorOptional;
  static inline ::test::typesinprotocols::VectorOptional Convert(::test_typesinprotocols::VectorOptional&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::VectorOptional> {
  using NaturalType = ::test_typesinprotocols::VectorOptional;
  static inline ::test_typesinprotocols::VectorOptional Convert(::test::typesinprotocols::VectorOptional&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ArrayVectorNested> {
  using HLCPPType = ::test::typesinprotocols::ArrayVectorNested;
  static inline ::test::typesinprotocols::ArrayVectorNested Convert(::test_typesinprotocols::ArrayVectorNested&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::ArrayVectorNested> {
  using NaturalType = ::test_typesinprotocols::ArrayVectorNested;
  static inline ::test_typesinprotocols::ArrayVectorNested Convert(::test::typesinprotocols::ArrayVectorNested&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Resource> {
  using HLCPPType = ::test::typesinprotocols::Resource;
  static inline ::test::typesinprotocols::Resource Convert(::test_typesinprotocols::Resource&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Resource> {
  using NaturalType = ::test_typesinprotocols::Resource;
  static inline ::test_typesinprotocols::Resource Convert(::test::typesinprotocols::Resource&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Table> {
  using HLCPPType = ::test::typesinprotocols::Table;
  static inline ::test::typesinprotocols::Table Convert(::test_typesinprotocols::Table&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Table> {
  using NaturalType = ::test_typesinprotocols::Table;
  static inline ::test_typesinprotocols::Table Convert(::test::typesinprotocols::Table&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceTable> {
  using HLCPPType = ::test::typesinprotocols::ResourceTable;
  static inline ::test::typesinprotocols::ResourceTable Convert(::test_typesinprotocols::ResourceTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceTable> {
  using NaturalType = ::test_typesinprotocols::ResourceTable;
  static inline ::test_typesinprotocols::ResourceTable Convert(::test::typesinprotocols::ResourceTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::Union> {
  using HLCPPType = ::test::typesinprotocols::Union;
  static inline ::test::typesinprotocols::Union Convert(::test_typesinprotocols::Union&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Union> {
  using NaturalType = ::test_typesinprotocols::Union;
  static inline ::test_typesinprotocols::Union Convert(::test::typesinprotocols::Union&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceUnion> {
  using HLCPPType = ::test::typesinprotocols::ResourceUnion;
  static inline ::test::typesinprotocols::ResourceUnion Convert(::test_typesinprotocols::ResourceUnion&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceUnion> {
  using NaturalType = ::test_typesinprotocols::ResourceUnion;
  static inline ::test_typesinprotocols::ResourceUnion Convert(::test::typesinprotocols::ResourceUnion&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorBasicResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorBasic_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorBasic_Result Convert(::test_typesinprotocols::ProtocolErrorBasicResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorBasic_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorBasicResult;
  static inline ::test_typesinprotocols::ProtocolErrorBasicResult Convert(::test::typesinprotocols::Protocol_ErrorBasic_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorCompoundResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorCompound_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorCompound_Result Convert(::test_typesinprotocols::ProtocolErrorCompoundResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorCompound_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorCompoundResult;
  static inline ::test_typesinprotocols::ProtocolErrorCompoundResult Convert(::test::typesinprotocols::Protocol_ErrorCompound_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayBasicResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result Convert(::test_typesinprotocols::ProtocolErrorArrayBasicResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorArrayBasicResult;
  static inline ::test_typesinprotocols::ProtocolErrorArrayBasicResult Convert(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayCompoundResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result Convert(::test_typesinprotocols::ProtocolErrorArrayCompoundResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorArrayCompoundResult;
  static inline ::test_typesinprotocols::ProtocolErrorArrayCompoundResult Convert(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorBasicResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result Convert(::test_typesinprotocols::ProtocolErrorVectorBasicResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorVectorBasicResult;
  static inline ::test_typesinprotocols::ProtocolErrorVectorBasicResult Convert(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorCompoundResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result Convert(::test_typesinprotocols::ProtocolErrorVectorCompoundResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorVectorCompoundResult;
  static inline ::test_typesinprotocols::ProtocolErrorVectorCompoundResult Convert(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorOptionalResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result Convert(::test_typesinprotocols::ProtocolErrorVectorOptionalResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorVectorOptionalResult;
  static inline ::test_typesinprotocols::ProtocolErrorVectorOptionalResult Convert(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result Convert(::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult;
  static inline ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult Convert(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorResourceResult> {
  using HLCPPType = ::test::typesinprotocols::Protocol_ErrorResource_Result;
  static inline ::test::typesinprotocols::Protocol_ErrorResource_Result Convert(::test_typesinprotocols::ProtocolErrorResourceResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorResource_Result> {
  using NaturalType = ::test_typesinprotocols::ProtocolErrorResourceResult;
  static inline ::test_typesinprotocols::ProtocolErrorResourceResult Convert(::test::typesinprotocols::Protocol_ErrorResource_Result&&);
};

::test::typesinprotocols::Struct NaturalToHLCPPTraits<::test_typesinprotocols::Struct>::Convert(::test_typesinprotocols::Struct&& value) {
  ::test::typesinprotocols::Struct hlcpp;
  hlcpp.__reserved = ::fidl::NaturalToHLCPP(std::move(value.__reserved()));
  return hlcpp;
}

::test_typesinprotocols::Struct HLCPPToNaturalTraits<::test::typesinprotocols::Struct>::Convert(::test::typesinprotocols::Struct&& value) {
  return ::test_typesinprotocols::Struct{{
      .__reserved = ::fidl::HLCPPToNatural(std::move(value.__reserved)),
  }};
}
::test::typesinprotocols::ResourceStruct NaturalToHLCPPTraits<::test_typesinprotocols::ResourceStruct>::Convert(::test_typesinprotocols::ResourceStruct&& value) {
  ::test::typesinprotocols::ResourceStruct hlcpp;
  hlcpp.__reserved = ::fidl::NaturalToHLCPP(std::move(value.__reserved()));
  return hlcpp;
}

::test_typesinprotocols::ResourceStruct HLCPPToNaturalTraits<::test::typesinprotocols::ResourceStruct>::Convert(::test::typesinprotocols::ResourceStruct&& value) {
  return ::test_typesinprotocols::ResourceStruct{{
      .__reserved = ::fidl::HLCPPToNatural(std::move(value.__reserved)),
  }};
}
::test::typesinprotocols::Basic NaturalToHLCPPTraits<::test_typesinprotocols::Basic>::Convert(::test_typesinprotocols::Basic&& value) {
  ::test::typesinprotocols::Basic hlcpp;
  hlcpp.uint8 = ::fidl::NaturalToHLCPP(std::move(value.uint8()));
  hlcpp.uint16 = ::fidl::NaturalToHLCPP(std::move(value.uint16()));
  hlcpp.uint32 = ::fidl::NaturalToHLCPP(std::move(value.uint32()));
  hlcpp.uint64 = ::fidl::NaturalToHLCPP(std::move(value.uint64()));
  hlcpp.int8 = ::fidl::NaturalToHLCPP(std::move(value.int8()));
  hlcpp.int16 = ::fidl::NaturalToHLCPP(std::move(value.int16()));
  hlcpp.int32 = ::fidl::NaturalToHLCPP(std::move(value.int32()));
  hlcpp.int64 = ::fidl::NaturalToHLCPP(std::move(value.int64()));
  hlcpp.float32 = ::fidl::NaturalToHLCPP(std::move(value.float32()));
  hlcpp.float64 = ::fidl::NaturalToHLCPP(std::move(value.float64()));
  hlcpp.string = ::fidl::NaturalToHLCPP(std::move(value.string()));
  hlcpp.opt_string = ::fidl::NaturalToHLCPP(std::move(value.opt_string()));
  return hlcpp;
}

::test_typesinprotocols::Basic HLCPPToNaturalTraits<::test::typesinprotocols::Basic>::Convert(::test::typesinprotocols::Basic&& value) {
  return ::test_typesinprotocols::Basic{{
      .uint8 = ::fidl::HLCPPToNatural(std::move(value.uint8)),
      .uint16 = ::fidl::HLCPPToNatural(std::move(value.uint16)),
      .uint32 = ::fidl::HLCPPToNatural(std::move(value.uint32)),
      .uint64 = ::fidl::HLCPPToNatural(std::move(value.uint64)),
      .int8 = ::fidl::HLCPPToNatural(std::move(value.int8)),
      .int16 = ::fidl::HLCPPToNatural(std::move(value.int16)),
      .int32 = ::fidl::HLCPPToNatural(std::move(value.int32)),
      .int64 = ::fidl::HLCPPToNatural(std::move(value.int64)),
      .float32 = ::fidl::HLCPPToNatural(std::move(value.float32)),
      .float64 = ::fidl::HLCPPToNatural(std::move(value.float64)),
      .string = ::fidl::HLCPPToNatural(std::move(value.string)),
      .opt_string = ::fidl::HLCPPToNatural(std::move(value.opt_string)),
  }};
}
::test::typesinprotocols::Compound NaturalToHLCPPTraits<::test_typesinprotocols::Compound>::Convert(::test_typesinprotocols::Compound&& value) {
  ::test::typesinprotocols::Compound hlcpp;
  hlcpp.bits = ::fidl::NaturalToHLCPP(std::move(value.bits()));
  hlcpp.enum_ = ::fidl::NaturalToHLCPP(std::move(value.enum_()));
  hlcpp.struct_ = ::fidl::NaturalToHLCPP(std::move(value.struct_()));
  hlcpp.table = ::fidl::NaturalToHLCPP(std::move(value.table()));
  hlcpp.union_ = ::fidl::NaturalToHLCPP(std::move(value.union_()));
  hlcpp.opt_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_struct()));
  hlcpp.opt_union = ::fidl::NaturalToHLCPP(std::move(value.opt_union()));
  return hlcpp;
}

::test_typesinprotocols::Compound HLCPPToNaturalTraits<::test::typesinprotocols::Compound>::Convert(::test::typesinprotocols::Compound&& value) {
  return ::test_typesinprotocols::Compound{{
      .bits = ::fidl::HLCPPToNatural(std::move(value.bits)),
      .enum_ = ::fidl::HLCPPToNatural(std::move(value.enum_)),
      .struct_ = ::fidl::HLCPPToNatural(std::move(value.struct_)),
      .table = ::fidl::HLCPPToNatural(std::move(value.table)),
      .union_ = ::fidl::HLCPPToNatural(std::move(value.union_)),
      .opt_struct = ::fidl::HLCPPToNatural(std::move(value.opt_struct)),
      .opt_union = ::fidl::HLCPPToNatural(std::move(value.opt_union)),
  }};
}
::test::typesinprotocols::ArrayBasic NaturalToHLCPPTraits<::test_typesinprotocols::ArrayBasic>::Convert(::test_typesinprotocols::ArrayBasic&& value) {
  ::test::typesinprotocols::ArrayBasic hlcpp;
  hlcpp.array_uint8 = ::fidl::NaturalToHLCPP(std::move(value.array_uint8()));
  hlcpp.array_uint16 = ::fidl::NaturalToHLCPP(std::move(value.array_uint16()));
  hlcpp.array_uint32 = ::fidl::NaturalToHLCPP(std::move(value.array_uint32()));
  hlcpp.array_uint64 = ::fidl::NaturalToHLCPP(std::move(value.array_uint64()));
  hlcpp.array_int8 = ::fidl::NaturalToHLCPP(std::move(value.array_int8()));
  hlcpp.array_int16 = ::fidl::NaturalToHLCPP(std::move(value.array_int16()));
  hlcpp.array_int32 = ::fidl::NaturalToHLCPP(std::move(value.array_int32()));
  hlcpp.array_int64 = ::fidl::NaturalToHLCPP(std::move(value.array_int64()));
  hlcpp.array_float32 = ::fidl::NaturalToHLCPP(std::move(value.array_float32()));
  hlcpp.array_float64 = ::fidl::NaturalToHLCPP(std::move(value.array_float64()));
  hlcpp.array_string = ::fidl::NaturalToHLCPP(std::move(value.array_string()));
  hlcpp.array_opt_string = ::fidl::NaturalToHLCPP(std::move(value.array_opt_string()));
  return hlcpp;
}

::test_typesinprotocols::ArrayBasic HLCPPToNaturalTraits<::test::typesinprotocols::ArrayBasic>::Convert(::test::typesinprotocols::ArrayBasic&& value) {
  return ::test_typesinprotocols::ArrayBasic{{
      .array_uint8 = ::fidl::HLCPPToNatural(std::move(value.array_uint8)),
      .array_uint16 = ::fidl::HLCPPToNatural(std::move(value.array_uint16)),
      .array_uint32 = ::fidl::HLCPPToNatural(std::move(value.array_uint32)),
      .array_uint64 = ::fidl::HLCPPToNatural(std::move(value.array_uint64)),
      .array_int8 = ::fidl::HLCPPToNatural(std::move(value.array_int8)),
      .array_int16 = ::fidl::HLCPPToNatural(std::move(value.array_int16)),
      .array_int32 = ::fidl::HLCPPToNatural(std::move(value.array_int32)),
      .array_int64 = ::fidl::HLCPPToNatural(std::move(value.array_int64)),
      .array_float32 = ::fidl::HLCPPToNatural(std::move(value.array_float32)),
      .array_float64 = ::fidl::HLCPPToNatural(std::move(value.array_float64)),
      .array_string = ::fidl::HLCPPToNatural(std::move(value.array_string)),
      .array_opt_string = ::fidl::HLCPPToNatural(std::move(value.array_opt_string)),
  }};
}
::test::typesinprotocols::ArrayCompound NaturalToHLCPPTraits<::test_typesinprotocols::ArrayCompound>::Convert(::test_typesinprotocols::ArrayCompound&& value) {
  ::test::typesinprotocols::ArrayCompound hlcpp;
  hlcpp.array_bits = ::fidl::NaturalToHLCPP(std::move(value.array_bits()));
  hlcpp.array_enum = ::fidl::NaturalToHLCPP(std::move(value.array_enum()));
  hlcpp.array_struct = ::fidl::NaturalToHLCPP(std::move(value.array_struct()));
  hlcpp.array_table = ::fidl::NaturalToHLCPP(std::move(value.array_table()));
  hlcpp.array_union = ::fidl::NaturalToHLCPP(std::move(value.array_union()));
  hlcpp.array_opt_struct = ::fidl::NaturalToHLCPP(std::move(value.array_opt_struct()));
  hlcpp.array_opt_union = ::fidl::NaturalToHLCPP(std::move(value.array_opt_union()));
  return hlcpp;
}

::test_typesinprotocols::ArrayCompound HLCPPToNaturalTraits<::test::typesinprotocols::ArrayCompound>::Convert(::test::typesinprotocols::ArrayCompound&& value) {
  return ::test_typesinprotocols::ArrayCompound{{
      .array_bits = ::fidl::HLCPPToNatural(std::move(value.array_bits)),
      .array_enum = ::fidl::HLCPPToNatural(std::move(value.array_enum)),
      .array_struct = ::fidl::HLCPPToNatural(std::move(value.array_struct)),
      .array_table = ::fidl::HLCPPToNatural(std::move(value.array_table)),
      .array_union = ::fidl::HLCPPToNatural(std::move(value.array_union)),
      .array_opt_struct = ::fidl::HLCPPToNatural(std::move(value.array_opt_struct)),
      .array_opt_union = ::fidl::HLCPPToNatural(std::move(value.array_opt_union)),
  }};
}
::test::typesinprotocols::VectorBasic NaturalToHLCPPTraits<::test_typesinprotocols::VectorBasic>::Convert(::test_typesinprotocols::VectorBasic&& value) {
  ::test::typesinprotocols::VectorBasic hlcpp;
  hlcpp.vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint8()));
  hlcpp.vector_uint16 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint16()));
  hlcpp.vector_uint32 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint32()));
  hlcpp.vector_uint64 = ::fidl::NaturalToHLCPP(std::move(value.vector_uint64()));
  hlcpp.vector_int8 = ::fidl::NaturalToHLCPP(std::move(value.vector_int8()));
  hlcpp.vector_int16 = ::fidl::NaturalToHLCPP(std::move(value.vector_int16()));
  hlcpp.vector_int32 = ::fidl::NaturalToHLCPP(std::move(value.vector_int32()));
  hlcpp.vector_int64 = ::fidl::NaturalToHLCPP(std::move(value.vector_int64()));
  hlcpp.vector_float32 = ::fidl::NaturalToHLCPP(std::move(value.vector_float32()));
  hlcpp.vector_float64 = ::fidl::NaturalToHLCPP(std::move(value.vector_float64()));
  hlcpp.vector_string = ::fidl::NaturalToHLCPP(std::move(value.vector_string()));
  hlcpp.vector_opt_string = ::fidl::NaturalToHLCPP(std::move(value.vector_opt_string()));
  return hlcpp;
}

::test_typesinprotocols::VectorBasic HLCPPToNaturalTraits<::test::typesinprotocols::VectorBasic>::Convert(::test::typesinprotocols::VectorBasic&& value) {
  return ::test_typesinprotocols::VectorBasic{{
      .vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.vector_uint8)),
      .vector_uint16 = ::fidl::HLCPPToNatural(std::move(value.vector_uint16)),
      .vector_uint32 = ::fidl::HLCPPToNatural(std::move(value.vector_uint32)),
      .vector_uint64 = ::fidl::HLCPPToNatural(std::move(value.vector_uint64)),
      .vector_int8 = ::fidl::HLCPPToNatural(std::move(value.vector_int8)),
      .vector_int16 = ::fidl::HLCPPToNatural(std::move(value.vector_int16)),
      .vector_int32 = ::fidl::HLCPPToNatural(std::move(value.vector_int32)),
      .vector_int64 = ::fidl::HLCPPToNatural(std::move(value.vector_int64)),
      .vector_float32 = ::fidl::HLCPPToNatural(std::move(value.vector_float32)),
      .vector_float64 = ::fidl::HLCPPToNatural(std::move(value.vector_float64)),
      .vector_string = ::fidl::HLCPPToNatural(std::move(value.vector_string)),
      .vector_opt_string = ::fidl::HLCPPToNatural(std::move(value.vector_opt_string)),
  }};
}
::test::typesinprotocols::VectorCompound NaturalToHLCPPTraits<::test_typesinprotocols::VectorCompound>::Convert(::test_typesinprotocols::VectorCompound&& value) {
  ::test::typesinprotocols::VectorCompound hlcpp;
  hlcpp.vector_bits = ::fidl::NaturalToHLCPP(std::move(value.vector_bits()));
  hlcpp.vector_enum = ::fidl::NaturalToHLCPP(std::move(value.vector_enum()));
  hlcpp.vector_struct = ::fidl::NaturalToHLCPP(std::move(value.vector_struct()));
  hlcpp.vector_table = ::fidl::NaturalToHLCPP(std::move(value.vector_table()));
  hlcpp.vector_union = ::fidl::NaturalToHLCPP(std::move(value.vector_union()));
  hlcpp.vector_opt_struct = ::fidl::NaturalToHLCPP(std::move(value.vector_opt_struct()));
  hlcpp.vector_opt_union = ::fidl::NaturalToHLCPP(std::move(value.vector_opt_union()));
  return hlcpp;
}

::test_typesinprotocols::VectorCompound HLCPPToNaturalTraits<::test::typesinprotocols::VectorCompound>::Convert(::test::typesinprotocols::VectorCompound&& value) {
  return ::test_typesinprotocols::VectorCompound{{
      .vector_bits = ::fidl::HLCPPToNatural(std::move(value.vector_bits)),
      .vector_enum = ::fidl::HLCPPToNatural(std::move(value.vector_enum)),
      .vector_struct = ::fidl::HLCPPToNatural(std::move(value.vector_struct)),
      .vector_table = ::fidl::HLCPPToNatural(std::move(value.vector_table)),
      .vector_union = ::fidl::HLCPPToNatural(std::move(value.vector_union)),
      .vector_opt_struct = ::fidl::HLCPPToNatural(std::move(value.vector_opt_struct)),
      .vector_opt_union = ::fidl::HLCPPToNatural(std::move(value.vector_opt_union)),
  }};
}
::test::typesinprotocols::VectorOptional NaturalToHLCPPTraits<::test_typesinprotocols::VectorOptional>::Convert(::test_typesinprotocols::VectorOptional&& value) {
  ::test::typesinprotocols::VectorOptional hlcpp;
  hlcpp.opt_vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_uint8()));
  hlcpp.opt_vector_string = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_string()));
  hlcpp.opt_vector_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_struct()));
  hlcpp.opt_vector_opt_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_vector_opt_struct()));
  return hlcpp;
}

::test_typesinprotocols::VectorOptional HLCPPToNaturalTraits<::test::typesinprotocols::VectorOptional>::Convert(::test::typesinprotocols::VectorOptional&& value) {
  return ::test_typesinprotocols::VectorOptional{{
      .opt_vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.opt_vector_uint8)),
      .opt_vector_string = ::fidl::HLCPPToNatural(std::move(value.opt_vector_string)),
      .opt_vector_struct = ::fidl::HLCPPToNatural(std::move(value.opt_vector_struct)),
      .opt_vector_opt_struct = ::fidl::HLCPPToNatural(std::move(value.opt_vector_opt_struct)),
  }};
}
::test::typesinprotocols::ArrayVectorNested NaturalToHLCPPTraits<::test_typesinprotocols::ArrayVectorNested>::Convert(::test_typesinprotocols::ArrayVectorNested&& value) {
  ::test::typesinprotocols::ArrayVectorNested hlcpp;
  hlcpp.array_array_uint8 = ::fidl::NaturalToHLCPP(std::move(value.array_array_uint8()));
  hlcpp.array_vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.array_vector_uint8()));
  hlcpp.vector_array_uint8 = ::fidl::NaturalToHLCPP(std::move(value.vector_array_uint8()));
  hlcpp.vector_vector_uint8 = ::fidl::NaturalToHLCPP(std::move(value.vector_vector_uint8()));
  return hlcpp;
}

::test_typesinprotocols::ArrayVectorNested HLCPPToNaturalTraits<::test::typesinprotocols::ArrayVectorNested>::Convert(::test::typesinprotocols::ArrayVectorNested&& value) {
  return ::test_typesinprotocols::ArrayVectorNested{{
      .array_array_uint8 = ::fidl::HLCPPToNatural(std::move(value.array_array_uint8)),
      .array_vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.array_vector_uint8)),
      .vector_array_uint8 = ::fidl::HLCPPToNatural(std::move(value.vector_array_uint8)),
      .vector_vector_uint8 = ::fidl::HLCPPToNatural(std::move(value.vector_vector_uint8)),
  }};
}
::test::typesinprotocols::Resource NaturalToHLCPPTraits<::test_typesinprotocols::Resource>::Convert(::test_typesinprotocols::Resource&& value) {
  ::test::typesinprotocols::Resource hlcpp;
  hlcpp.handle = ::fidl::NaturalToHLCPP(std::move(value.handle()));
  hlcpp.vmo = ::fidl::NaturalToHLCPP(std::move(value.vmo()));
  hlcpp.client_end = ::fidl::NaturalToHLCPP(std::move(value.client_end()));
  hlcpp.server_end = ::fidl::NaturalToHLCPP(std::move(value.server_end()));
  hlcpp.struct_ = ::fidl::NaturalToHLCPP(std::move(value.struct_()));
  hlcpp.table = ::fidl::NaturalToHLCPP(std::move(value.table()));
  hlcpp.union_ = ::fidl::NaturalToHLCPP(std::move(value.union_()));
  hlcpp.opt_handle = ::fidl::NaturalToHLCPP(std::move(value.opt_handle()));
  hlcpp.opt_vmo = ::fidl::NaturalToHLCPP(std::move(value.opt_vmo()));
  hlcpp.opt_client_end = ::fidl::NaturalToHLCPP(std::move(value.opt_client_end()));
  hlcpp.opt_server_end = ::fidl::NaturalToHLCPP(std::move(value.opt_server_end()));
  hlcpp.opt_struct = ::fidl::NaturalToHLCPP(std::move(value.opt_struct()));
  hlcpp.opt_union = ::fidl::NaturalToHLCPP(std::move(value.opt_union()));
  hlcpp.array_handle = ::fidl::NaturalToHLCPP(std::move(value.array_handle()));
  hlcpp.array_vmo = ::fidl::NaturalToHLCPP(std::move(value.array_vmo()));
  hlcpp.array_client_end = ::fidl::NaturalToHLCPP(std::move(value.array_client_end()));
  hlcpp.array_server_end = ::fidl::NaturalToHLCPP(std::move(value.array_server_end()));
  hlcpp.array_struct = ::fidl::NaturalToHLCPP(std::move(value.array_struct()));
  hlcpp.array_table = ::fidl::NaturalToHLCPP(std::move(value.array_table()));
  hlcpp.array_union = ::fidl::NaturalToHLCPP(std::move(value.array_union()));
  hlcpp.vector_handle = ::fidl::NaturalToHLCPP(std::move(value.vector_handle()));
  hlcpp.vector_vmo = ::fidl::NaturalToHLCPP(std::move(value.vector_vmo()));
  hlcpp.vector_client_end = ::fidl::NaturalToHLCPP(std::move(value.vector_client_end()));
  hlcpp.vector_server_end = ::fidl::NaturalToHLCPP(std::move(value.vector_server_end()));
  hlcpp.vector_struct = ::fidl::NaturalToHLCPP(std::move(value.vector_struct()));
  hlcpp.vector_table = ::fidl::NaturalToHLCPP(std::move(value.vector_table()));
  hlcpp.vector_union = ::fidl::NaturalToHLCPP(std::move(value.vector_union()));
  return hlcpp;
}

::test_typesinprotocols::Resource HLCPPToNaturalTraits<::test::typesinprotocols::Resource>::Convert(::test::typesinprotocols::Resource&& value) {
  return ::test_typesinprotocols::Resource{{
      .handle = ::fidl::HLCPPToNatural(std::move(value.handle)),
      .vmo = ::fidl::HLCPPToNatural(std::move(value.vmo)),
      .client_end = ::fidl::HLCPPToNatural(std::move(value.client_end)),
      .server_end = ::fidl::HLCPPToNatural(std::move(value.server_end)),
      .struct_ = ::fidl::HLCPPToNatural(std::move(value.struct_)),
      .table = ::fidl::HLCPPToNatural(std::move(value.table)),
      .union_ = ::fidl::HLCPPToNatural(std::move(value.union_)),
      .opt_handle = ::fidl::HLCPPToNatural(std::move(value.opt_handle)),
      .opt_vmo = ::fidl::HLCPPToNatural(std::move(value.opt_vmo)),
      .opt_client_end = ::fidl::HLCPPToNatural(std::move(value.opt_client_end)),
      .opt_server_end = ::fidl::HLCPPToNatural(std::move(value.opt_server_end)),
      .opt_struct = ::fidl::HLCPPToNatural(std::move(value.opt_struct)),
      .opt_union = ::fidl::HLCPPToNatural(std::move(value.opt_union)),
      .array_handle = ::fidl::HLCPPToNatural(std::move(value.array_handle)),
      .array_vmo = ::fidl::HLCPPToNatural(std::move(value.array_vmo)),
      .array_client_end = ::fidl::HLCPPToNatural(std::move(value.array_client_end)),
      .array_server_end = ::fidl::HLCPPToNatural(std::move(value.array_server_end)),
      .array_struct = ::fidl::HLCPPToNatural(std::move(value.array_struct)),
      .array_table = ::fidl::HLCPPToNatural(std::move(value.array_table)),
      .array_union = ::fidl::HLCPPToNatural(std::move(value.array_union)),
      .vector_handle = ::fidl::HLCPPToNatural(std::move(value.vector_handle)),
      .vector_vmo = ::fidl::HLCPPToNatural(std::move(value.vector_vmo)),
      .vector_client_end = ::fidl::HLCPPToNatural(std::move(value.vector_client_end)),
      .vector_server_end = ::fidl::HLCPPToNatural(std::move(value.vector_server_end)),
      .vector_struct = ::fidl::HLCPPToNatural(std::move(value.vector_struct)),
      .vector_table = ::fidl::HLCPPToNatural(std::move(value.vector_table)),
      .vector_union = ::fidl::HLCPPToNatural(std::move(value.vector_union)),
  }};
}
::test::typesinprotocols::Table NaturalToHLCPPTraits<::test_typesinprotocols::Table>::Convert(::test_typesinprotocols::Table&& value) {
  ::test::typesinprotocols::Table hlcpp;
  return hlcpp;
}

::test_typesinprotocols::Table HLCPPToNaturalTraits<::test::typesinprotocols::Table>::Convert(::test::typesinprotocols::Table&& value) {
  ::test_typesinprotocols::Table natural;
  return natural;
}
::test::typesinprotocols::ResourceTable NaturalToHLCPPTraits<::test_typesinprotocols::ResourceTable>::Convert(::test_typesinprotocols::ResourceTable&& value) {
  ::test::typesinprotocols::ResourceTable hlcpp;
  return hlcpp;
}

::test_typesinprotocols::ResourceTable HLCPPToNaturalTraits<::test::typesinprotocols::ResourceTable>::Convert(::test::typesinprotocols::ResourceTable&& value) {
  ::test_typesinprotocols::ResourceTable natural;
  return natural;
}

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

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

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

::test_typesinprotocols::ProtocolErrorBasicResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorBasic_Result>::Convert(::test::typesinprotocols::Protocol_ErrorBasic_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorBasicResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorBasic_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::typesinprotocols::Protocol_ErrorBasic_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorCompound_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorCompoundResult>::Convert(::test_typesinprotocols::ProtocolErrorCompoundResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorCompound_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorCompoundResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorCompoundResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorCompoundResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorCompound_Result>::Convert(::test::typesinprotocols::Protocol_ErrorCompound_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorCompoundResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorCompound_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::typesinprotocols::Protocol_ErrorCompound_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorArrayBasic_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayBasicResult>::Convert(::test_typesinprotocols::ProtocolErrorArrayBasicResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorArrayBasicResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorArrayBasicResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorArrayBasicResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result>::Convert(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorArrayBasicResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorArrayBasic_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::typesinprotocols::Protocol_ErrorArrayBasic_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorArrayCompound_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayCompoundResult>::Convert(::test_typesinprotocols::ProtocolErrorArrayCompoundResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorArrayCompoundResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorArrayCompoundResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorArrayCompoundResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result>::Convert(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorArrayCompoundResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorArrayCompound_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::typesinprotocols::Protocol_ErrorArrayCompound_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorVectorBasic_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorBasicResult>::Convert(::test_typesinprotocols::ProtocolErrorVectorBasicResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorVectorBasicResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorVectorBasicResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorVectorBasicResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result>::Convert(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorVectorBasicResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorVectorBasic_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::typesinprotocols::Protocol_ErrorVectorBasic_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorVectorCompound_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorCompoundResult>::Convert(::test_typesinprotocols::ProtocolErrorVectorCompoundResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorVectorCompoundResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorVectorCompoundResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorVectorCompoundResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result>::Convert(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorVectorCompoundResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorVectorCompound_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::typesinprotocols::Protocol_ErrorVectorCompound_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorVectorOptional_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorVectorOptionalResult>::Convert(::test_typesinprotocols::ProtocolErrorVectorOptionalResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorVectorOptionalResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorVectorOptionalResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorVectorOptionalResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result>::Convert(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorVectorOptionalResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorVectorOptional_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::typesinprotocols::Protocol_ErrorVectorOptional_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult>::Convert(::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result>::Convert(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_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::typesinprotocols::Protocol_ErrorArrayVectorNested_Result");
  }
}
::test::typesinprotocols::Protocol_ErrorResource_Result NaturalToHLCPPTraits<::test_typesinprotocols::ProtocolErrorResourceResult>::Convert(::test_typesinprotocols::ProtocolErrorResourceResult&& value) {
  ::test::typesinprotocols::Protocol_ErrorResource_Result hlcpp;
  switch (value.Which()) {
    case ::test_typesinprotocols::ProtocolErrorResourceResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_typesinprotocols::ProtocolErrorResourceResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_typesinprotocols::ProtocolErrorResourceResult HLCPPToNaturalTraits<::test::typesinprotocols::Protocol_ErrorResource_Result>::Convert(::test::typesinprotocols::Protocol_ErrorResource_Result&& value) {
  using _NaturalUnion = ::test_typesinprotocols::ProtocolErrorResourceResult;
  switch (value.Which()) {
    case ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::typesinprotocols::Protocol_ErrorResource_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::typesinprotocols::Protocol_ErrorResource_Result");
  }
}

#pragma clang diagnostic pop

}  // namespace internal
}  // namespace fidl