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

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

// fidl_experiment = output_index_json

#pragma once

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

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

namespace fidl {
namespace internal {

template <>
struct NaturalToHLCPPTraits<::test_protocols::ErrorEnum> : public NaturalToHLCPPTraitsEnum<::test_protocols::ErrorEnum, ::test::protocols::ErrorEnum, uint32_t> {};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ErrorEnum> : public HLCPPToNaturalTraitsEnum<::test::protocols::ErrorEnum, ::test_protocols::ErrorEnum> {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
struct NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse> {
  using HLCPPType = ::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse;
  static inline ::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse Convert(::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse> {
  using NaturalType = ::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse;
  static inline ::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse Convert(::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest> {
  using HLCPPType = ::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest;
  static inline ::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest> {
  using NaturalType = ::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest;
  static inline ::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest> {
  using HLCPPType = ::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest;
  static inline ::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest> {
  using NaturalType = ::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest;
  static inline ::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest> {
  using HLCPPType = ::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest;
  static inline ::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest> {
  using NaturalType = ::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest;
  static inline ::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse> {
  using HLCPPType = ::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse;
  static inline ::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse> {
  using NaturalType = ::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse;
  static inline ::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest> {
  using HLCPPType = ::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest;
  static inline ::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest Convert(::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest> {
  using NaturalType = ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest;
  static inline ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest Convert(::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxResponseAsStructResponse> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_ResponseAsStruct_Response;
  static inline ::test::protocols::WithErrorSyntax_ResponseAsStruct_Response Convert(::test_protocols::WithErrorSyntaxResponseAsStructResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ResponseAsStruct_Response> {
  using NaturalType = ::test_protocols::WithErrorSyntaxResponseAsStructResponse;
  static inline ::test_protocols::WithErrorSyntaxResponseAsStructResponse Convert(::test::protocols::WithErrorSyntax_ResponseAsStruct_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response;
  static inline ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response Convert(::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response> {
  using NaturalType = ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse;
  static inline ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse Convert(::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsEnumResponse> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_ErrorAsEnum_Response;
  static inline ::test::protocols::WithErrorSyntax_ErrorAsEnum_Response Convert(::test_protocols::WithErrorSyntaxErrorAsEnumResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsEnum_Response> {
  using NaturalType = ::test_protocols::WithErrorSyntaxErrorAsEnumResponse;
  static inline ::test_protocols::WithErrorSyntaxErrorAsEnumResponse Convert(::test::protocols::WithErrorSyntax_ErrorAsEnum_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxHandleInResultResponse> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_HandleInResult_Response;
  static inline ::test::protocols::WithErrorSyntax_HandleInResult_Response Convert(::test_protocols::WithErrorSyntaxHandleInResultResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_HandleInResult_Response> {
  using NaturalType = ::test_protocols::WithErrorSyntaxHandleInResultResponse;
  static inline ::test_protocols::WithErrorSyntaxHandleInResultResponse Convert(::test::protocols::WithErrorSyntax_HandleInResult_Response&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMethodARequest> {
  using HLCPPType = ::test::protocols::ChannelProtocolMethodARequest;
  static inline ::test::protocols::ChannelProtocolMethodARequest Convert(::test_protocols::ChannelProtocolMethodARequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMethodARequest> {
  using NaturalType = ::test_protocols::ChannelProtocolMethodARequest;
  static inline ::test_protocols::ChannelProtocolMethodARequest Convert(::test::protocols::ChannelProtocolMethodARequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolEventARequest> {
  using HLCPPType = ::test::protocols::ChannelProtocolEventARequest;
  static inline ::test::protocols::ChannelProtocolEventARequest Convert(::test_protocols::ChannelProtocolEventARequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolEventARequest> {
  using NaturalType = ::test_protocols::ChannelProtocolEventARequest;
  static inline ::test_protocols::ChannelProtocolEventARequest Convert(::test::protocols::ChannelProtocolEventARequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMethodBRequest> {
  using HLCPPType = ::test::protocols::ChannelProtocolMethodBRequest;
  static inline ::test::protocols::ChannelProtocolMethodBRequest Convert(::test_protocols::ChannelProtocolMethodBRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMethodBRequest> {
  using NaturalType = ::test_protocols::ChannelProtocolMethodBRequest;
  static inline ::test_protocols::ChannelProtocolMethodBRequest Convert(::test::protocols::ChannelProtocolMethodBRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMethodBResponse> {
  using HLCPPType = ::test::protocols::ChannelProtocolMethodBResponse;
  static inline ::test::protocols::ChannelProtocolMethodBResponse Convert(::test_protocols::ChannelProtocolMethodBResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMethodBResponse> {
  using NaturalType = ::test_protocols::ChannelProtocolMethodBResponse;
  static inline ::test_protocols::ChannelProtocolMethodBResponse Convert(::test::protocols::ChannelProtocolMethodBResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolTakeHandleRequest> {
  using HLCPPType = ::test::protocols::ChannelProtocolTakeHandleRequest;
  static inline ::test::protocols::ChannelProtocolTakeHandleRequest Convert(::test_protocols::ChannelProtocolTakeHandleRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolTakeHandleRequest> {
  using NaturalType = ::test_protocols::ChannelProtocolTakeHandleRequest;
  static inline ::test_protocols::ChannelProtocolTakeHandleRequest Convert(::test::protocols::ChannelProtocolTakeHandleRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMutateSocketRequest> {
  using HLCPPType = ::test::protocols::ChannelProtocolMutateSocketRequest;
  static inline ::test::protocols::ChannelProtocolMutateSocketRequest Convert(::test_protocols::ChannelProtocolMutateSocketRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMutateSocketRequest> {
  using NaturalType = ::test_protocols::ChannelProtocolMutateSocketRequest;
  static inline ::test_protocols::ChannelProtocolMutateSocketRequest Convert(::test::protocols::ChannelProtocolMutateSocketRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMutateSocketResponse> {
  using HLCPPType = ::test::protocols::ChannelProtocolMutateSocketResponse;
  static inline ::test::protocols::ChannelProtocolMutateSocketResponse Convert(::test_protocols::ChannelProtocolMutateSocketResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMutateSocketResponse> {
  using NaturalType = ::test_protocols::ChannelProtocolMutateSocketResponse;
  static inline ::test_protocols::ChannelProtocolMutateSocketResponse Convert(::test::protocols::ChannelProtocolMutateSocketResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::SyscallProtocolMethodCRequest> {
  using HLCPPType = ::test::protocols::SyscallProtocolMethodCRequest;
  static inline ::test::protocols::SyscallProtocolMethodCRequest Convert(::test_protocols::SyscallProtocolMethodCRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::SyscallProtocolMethodCRequest> {
  using NaturalType = ::test_protocols::SyscallProtocolMethodCRequest;
  static inline ::test_protocols::SyscallProtocolMethodCRequest Convert(::test::protocols::SyscallProtocolMethodCRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolNoResponseMethodRequest> {
  using HLCPPType = ::test::protocols::HandleRightsProtocolNoResponseMethodRequest;
  static inline ::test::protocols::HandleRightsProtocolNoResponseMethodRequest Convert(::test_protocols::HandleRightsProtocolNoResponseMethodRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolNoResponseMethodRequest> {
  using NaturalType = ::test_protocols::HandleRightsProtocolNoResponseMethodRequest;
  static inline ::test_protocols::HandleRightsProtocolNoResponseMethodRequest Convert(::test::protocols::HandleRightsProtocolNoResponseMethodRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolResponseMethodRequest> {
  using HLCPPType = ::test::protocols::HandleRightsProtocolResponseMethodRequest;
  static inline ::test::protocols::HandleRightsProtocolResponseMethodRequest Convert(::test_protocols::HandleRightsProtocolResponseMethodRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolResponseMethodRequest> {
  using NaturalType = ::test_protocols::HandleRightsProtocolResponseMethodRequest;
  static inline ::test_protocols::HandleRightsProtocolResponseMethodRequest Convert(::test::protocols::HandleRightsProtocolResponseMethodRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolResponseMethodResponse> {
  using HLCPPType = ::test::protocols::HandleRightsProtocolResponseMethodResponse;
  static inline ::test::protocols::HandleRightsProtocolResponseMethodResponse Convert(::test_protocols::HandleRightsProtocolResponseMethodResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolResponseMethodResponse> {
  using NaturalType = ::test_protocols::HandleRightsProtocolResponseMethodResponse;
  static inline ::test_protocols::HandleRightsProtocolResponseMethodResponse Convert(::test::protocols::HandleRightsProtocolResponseMethodResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolAnEventRequest> {
  using HLCPPType = ::test::protocols::HandleRightsProtocolAnEventRequest;
  static inline ::test::protocols::HandleRightsProtocolAnEventRequest Convert(::test_protocols::HandleRightsProtocolAnEventRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolAnEventRequest> {
  using NaturalType = ::test_protocols::HandleRightsProtocolAnEventRequest;
  static inline ::test_protocols::HandleRightsProtocolAnEventRequest Convert(::test::protocols::HandleRightsProtocolAnEventRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ProtocolEnds> {
  using HLCPPType = ::test::protocols::ProtocolEnds;
  static inline ::test::protocols::ProtocolEnds Convert(::test_protocols::ProtocolEnds&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ProtocolEnds> {
  using NaturalType = ::test_protocols::ProtocolEnds;
  static inline ::test_protocols::ProtocolEnds Convert(::test::protocols::ProtocolEnds&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsClientEndsRequest> {
  using HLCPPType = ::test::protocols::WithProtocolEndsClientEndsRequest;
  static inline ::test::protocols::WithProtocolEndsClientEndsRequest Convert(::test_protocols::WithProtocolEndsClientEndsRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsClientEndsRequest> {
  using NaturalType = ::test_protocols::WithProtocolEndsClientEndsRequest;
  static inline ::test_protocols::WithProtocolEndsClientEndsRequest Convert(::test::protocols::WithProtocolEndsClientEndsRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsClientEndsResponse> {
  using HLCPPType = ::test::protocols::WithProtocolEndsClientEndsResponse;
  static inline ::test::protocols::WithProtocolEndsClientEndsResponse Convert(::test_protocols::WithProtocolEndsClientEndsResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsClientEndsResponse> {
  using NaturalType = ::test_protocols::WithProtocolEndsClientEndsResponse;
  static inline ::test_protocols::WithProtocolEndsClientEndsResponse Convert(::test::protocols::WithProtocolEndsClientEndsResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsServerEndsRequest> {
  using HLCPPType = ::test::protocols::WithProtocolEndsServerEndsRequest;
  static inline ::test::protocols::WithProtocolEndsServerEndsRequest Convert(::test_protocols::WithProtocolEndsServerEndsRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsServerEndsRequest> {
  using NaturalType = ::test_protocols::WithProtocolEndsServerEndsRequest;
  static inline ::test_protocols::WithProtocolEndsServerEndsRequest Convert(::test::protocols::WithProtocolEndsServerEndsRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsServerEndsResponse> {
  using HLCPPType = ::test::protocols::WithProtocolEndsServerEndsResponse;
  static inline ::test::protocols::WithProtocolEndsServerEndsResponse Convert(::test_protocols::WithProtocolEndsServerEndsResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsServerEndsResponse> {
  using NaturalType = ::test_protocols::WithProtocolEndsServerEndsResponse;
  static inline ::test_protocols::WithProtocolEndsServerEndsResponse Convert(::test::protocols::WithProtocolEndsServerEndsResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsStructContainingEndsRequest> {
  using HLCPPType = ::test::protocols::WithProtocolEndsStructContainingEndsRequest;
  static inline ::test::protocols::WithProtocolEndsStructContainingEndsRequest Convert(::test_protocols::WithProtocolEndsStructContainingEndsRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsStructContainingEndsRequest> {
  using NaturalType = ::test_protocols::WithProtocolEndsStructContainingEndsRequest;
  static inline ::test_protocols::WithProtocolEndsStructContainingEndsRequest Convert(::test::protocols::WithProtocolEndsStructContainingEndsRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsStructContainingEndsResponse> {
  using HLCPPType = ::test::protocols::WithProtocolEndsStructContainingEndsResponse;
  static inline ::test::protocols::WithProtocolEndsStructContainingEndsResponse Convert(::test_protocols::WithProtocolEndsStructContainingEndsResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsStructContainingEndsResponse> {
  using NaturalType = ::test_protocols::WithProtocolEndsStructContainingEndsResponse;
  static inline ::test_protocols::WithProtocolEndsStructContainingEndsResponse Convert(::test::protocols::WithProtocolEndsStructContainingEndsResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::ManyParametersFifteenRequest> {
  using HLCPPType = ::test::protocols::ManyParametersFifteenRequest;
  static inline ::test::protocols::ManyParametersFifteenRequest Convert(::test_protocols::ManyParametersFifteenRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::ManyParametersFifteenRequest> {
  using NaturalType = ::test_protocols::ManyParametersFifteenRequest;
  static inline ::test_protocols::ManyParametersFifteenRequest Convert(::test::protocols::ManyParametersFifteenRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::MethodWithUnionUnionMethodRequest> {
  using HLCPPType = ::test::protocols::MethodWithUnionUnionMethodRequest;
  static inline ::test::protocols::MethodWithUnionUnionMethodRequest Convert(::test_protocols::MethodWithUnionUnionMethodRequest&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::MethodWithUnionUnionMethodRequest> {
  using NaturalType = ::test_protocols::MethodWithUnionUnionMethodRequest;
  static inline ::test_protocols::MethodWithUnionUnionMethodRequest Convert(::test::protocols::MethodWithUnionUnionMethodRequest&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::MethodWithUnionUnionMethodResponse> {
  using HLCPPType = ::test::protocols::MethodWithUnionUnionMethodResponse;
  static inline ::test::protocols::MethodWithUnionUnionMethodResponse Convert(::test_protocols::MethodWithUnionUnionMethodResponse&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::MethodWithUnionUnionMethodResponse> {
  using NaturalType = ::test_protocols::MethodWithUnionUnionMethodResponse;
  static inline ::test_protocols::MethodWithUnionUnionMethodResponse Convert(::test::protocols::MethodWithUnionUnionMethodResponse&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxResponseAsStructResult> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_ResponseAsStruct_Result;
  static inline ::test::protocols::WithErrorSyntax_ResponseAsStruct_Result Convert(::test_protocols::WithErrorSyntaxResponseAsStructResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ResponseAsStruct_Result> {
  using NaturalType = ::test_protocols::WithErrorSyntaxResponseAsStructResult;
  static inline ::test_protocols::WithErrorSyntaxResponseAsStructResult Convert(::test::protocols::WithErrorSyntax_ResponseAsStruct_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result;
  static inline ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result Convert(::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result> {
  using NaturalType = ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult;
  static inline ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult Convert(::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsEnumResult> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_ErrorAsEnum_Result;
  static inline ::test::protocols::WithErrorSyntax_ErrorAsEnum_Result Convert(::test_protocols::WithErrorSyntaxErrorAsEnumResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsEnum_Result> {
  using NaturalType = ::test_protocols::WithErrorSyntaxErrorAsEnumResult;
  static inline ::test_protocols::WithErrorSyntaxErrorAsEnumResult Convert(::test::protocols::WithErrorSyntax_ErrorAsEnum_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxHandleInResultResult> {
  using HLCPPType = ::test::protocols::WithErrorSyntax_HandleInResult_Result;
  static inline ::test::protocols::WithErrorSyntax_HandleInResult_Result Convert(::test_protocols::WithErrorSyntaxHandleInResultResult&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_HandleInResult_Result> {
  using NaturalType = ::test_protocols::WithErrorSyntaxHandleInResultResult;
  static inline ::test_protocols::WithErrorSyntaxHandleInResultResult Convert(::test::protocols::WithErrorSyntax_HandleInResult_Result&&);
};
template <>
struct NaturalToHLCPPTraits<::test_protocols::TheUnion> {
  using HLCPPType = ::test::protocols::TheUnion;
  static inline ::test::protocols::TheUnion Convert(::test_protocols::TheUnion&&);
};
template <>
struct HLCPPToNaturalTraits<::test::protocols::TheUnion> {
  using NaturalType = ::test_protocols::TheUnion;
  static inline ::test_protocols::TheUnion Convert(::test::protocols::TheUnion&&);
};

::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse>::Convert(::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse&& value) {
  ::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse hlcpp;
  hlcpp.ret = ::fidl::NaturalToHLCPP(std::move(value.ret()));
  return hlcpp;
}

::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse>::Convert(::test::protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse&& value) {
  return ::test_protocols::WithAndWithoutRequestResponseNoRequestWithResponseResponse{{
      .ret = ::fidl::HLCPPToNatural(std::move(value.ret)),
  }};
}
::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest>::Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest&& value) {
  ::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest hlcpp;
  hlcpp.arg = ::fidl::NaturalToHLCPP(std::move(value.arg()));
  return hlcpp;
}

::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest>::Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest&& value) {
  return ::test_protocols::WithAndWithoutRequestResponseWithRequestNoResponseRequest{{
      .arg = ::fidl::HLCPPToNatural(std::move(value.arg)),
  }};
}
::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest>::Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest&& value) {
  ::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest hlcpp;
  hlcpp.arg = ::fidl::NaturalToHLCPP(std::move(value.arg()));
  return hlcpp;
}

::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest>::Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest&& value) {
  return ::test_protocols::WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{{
      .arg = ::fidl::HLCPPToNatural(std::move(value.arg)),
  }};
}
::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest>::Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest&& value) {
  ::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest hlcpp;
  hlcpp.arg = ::fidl::NaturalToHLCPP(std::move(value.arg()));
  return hlcpp;
}

::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest>::Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest&& value) {
  return ::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseRequest{{
      .arg = ::fidl::HLCPPToNatural(std::move(value.arg)),
  }};
}
::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse>::Convert(::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse&& value) {
  ::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse hlcpp;
  hlcpp.ret = ::fidl::NaturalToHLCPP(std::move(value.ret()));
  return hlcpp;
}

::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse>::Convert(::test::protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse&& value) {
  return ::test_protocols::WithAndWithoutRequestResponseWithRequestWithResponseResponse{{
      .ret = ::fidl::HLCPPToNatural(std::move(value.ret)),
  }};
}
::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest NaturalToHLCPPTraits<::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest>::Convert(::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest&& value) {
  ::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest hlcpp;
  hlcpp.ret = ::fidl::NaturalToHLCPP(std::move(value.ret()));
  return hlcpp;
}

::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest HLCPPToNaturalTraits<::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest>::Convert(::test::protocols::WithAndWithoutRequestResponseOnWithResponseRequest&& value) {
  return ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest{{
      .ret = ::fidl::HLCPPToNatural(std::move(value.ret)),
  }};
}
::test::protocols::WithErrorSyntax_ResponseAsStruct_Response NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxResponseAsStructResponse>::Convert(::test_protocols::WithErrorSyntaxResponseAsStructResponse&& value) {
  ::test::protocols::WithErrorSyntax_ResponseAsStruct_Response hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  hlcpp.c = ::fidl::NaturalToHLCPP(std::move(value.c()));
  return hlcpp;
}

::test_protocols::WithErrorSyntaxResponseAsStructResponse HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ResponseAsStruct_Response>::Convert(::test::protocols::WithErrorSyntax_ResponseAsStruct_Response&& value) {
  return ::test_protocols::WithErrorSyntaxResponseAsStructResponse{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
      .c = ::fidl::HLCPPToNatural(std::move(value.c)),
  }};
}
::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse>::Convert(::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse&& value) {
  ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response hlcpp;
  hlcpp.__reserved = ::fidl::NaturalToHLCPP(std::move(value.__reserved()));
  return hlcpp;
}

::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response>::Convert(::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Response&& value) {
  return ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResponse{{
      .__reserved = ::fidl::HLCPPToNatural(std::move(value.__reserved)),
  }};
}
::test::protocols::WithErrorSyntax_ErrorAsEnum_Response NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsEnumResponse>::Convert(::test_protocols::WithErrorSyntaxErrorAsEnumResponse&& value) {
  ::test::protocols::WithErrorSyntax_ErrorAsEnum_Response hlcpp;
  hlcpp.__reserved = ::fidl::NaturalToHLCPP(std::move(value.__reserved()));
  return hlcpp;
}

::test_protocols::WithErrorSyntaxErrorAsEnumResponse HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsEnum_Response>::Convert(::test::protocols::WithErrorSyntax_ErrorAsEnum_Response&& value) {
  return ::test_protocols::WithErrorSyntaxErrorAsEnumResponse{{
      .__reserved = ::fidl::HLCPPToNatural(std::move(value.__reserved)),
  }};
}
::test::protocols::WithErrorSyntax_HandleInResult_Response NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxHandleInResultResponse>::Convert(::test_protocols::WithErrorSyntaxHandleInResultResponse&& value) {
  ::test::protocols::WithErrorSyntax_HandleInResult_Response hlcpp;
  hlcpp.h = ::fidl::NaturalToHLCPP(std::move(value.h()));
  return hlcpp;
}

::test_protocols::WithErrorSyntaxHandleInResultResponse HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_HandleInResult_Response>::Convert(::test::protocols::WithErrorSyntax_HandleInResult_Response&& value) {
  return ::test_protocols::WithErrorSyntaxHandleInResultResponse{{
      .h = ::fidl::HLCPPToNatural(std::move(value.h)),
  }};
}
::test::protocols::ChannelProtocolMethodARequest NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMethodARequest>::Convert(::test_protocols::ChannelProtocolMethodARequest&& value) {
  ::test::protocols::ChannelProtocolMethodARequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocols::ChannelProtocolMethodARequest HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMethodARequest>::Convert(::test::protocols::ChannelProtocolMethodARequest&& value) {
  return ::test_protocols::ChannelProtocolMethodARequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocols::ChannelProtocolEventARequest NaturalToHLCPPTraits<::test_protocols::ChannelProtocolEventARequest>::Convert(::test_protocols::ChannelProtocolEventARequest&& value) {
  ::test::protocols::ChannelProtocolEventARequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocols::ChannelProtocolEventARequest HLCPPToNaturalTraits<::test::protocols::ChannelProtocolEventARequest>::Convert(::test::protocols::ChannelProtocolEventARequest&& value) {
  return ::test_protocols::ChannelProtocolEventARequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocols::ChannelProtocolMethodBRequest NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMethodBRequest>::Convert(::test_protocols::ChannelProtocolMethodBRequest&& value) {
  ::test::protocols::ChannelProtocolMethodBRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocols::ChannelProtocolMethodBRequest HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMethodBRequest>::Convert(::test::protocols::ChannelProtocolMethodBRequest&& value) {
  return ::test_protocols::ChannelProtocolMethodBRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocols::ChannelProtocolMethodBResponse NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMethodBResponse>::Convert(::test_protocols::ChannelProtocolMethodBResponse&& value) {
  ::test::protocols::ChannelProtocolMethodBResponse hlcpp;
  hlcpp.result = ::fidl::NaturalToHLCPP(std::move(value.result()));
  return hlcpp;
}

::test_protocols::ChannelProtocolMethodBResponse HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMethodBResponse>::Convert(::test::protocols::ChannelProtocolMethodBResponse&& value) {
  return ::test_protocols::ChannelProtocolMethodBResponse{{
      .result = ::fidl::HLCPPToNatural(std::move(value.result)),
  }};
}
::test::protocols::ChannelProtocolTakeHandleRequest NaturalToHLCPPTraits<::test_protocols::ChannelProtocolTakeHandleRequest>::Convert(::test_protocols::ChannelProtocolTakeHandleRequest&& value) {
  ::test::protocols::ChannelProtocolTakeHandleRequest hlcpp;
  hlcpp.h = ::fidl::NaturalToHLCPP(std::move(value.h()));
  return hlcpp;
}

::test_protocols::ChannelProtocolTakeHandleRequest HLCPPToNaturalTraits<::test::protocols::ChannelProtocolTakeHandleRequest>::Convert(::test::protocols::ChannelProtocolTakeHandleRequest&& value) {
  return ::test_protocols::ChannelProtocolTakeHandleRequest{{
      .h = ::fidl::HLCPPToNatural(std::move(value.h)),
  }};
}
::test::protocols::ChannelProtocolMutateSocketRequest NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMutateSocketRequest>::Convert(::test_protocols::ChannelProtocolMutateSocketRequest&& value) {
  ::test::protocols::ChannelProtocolMutateSocketRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  return hlcpp;
}

::test_protocols::ChannelProtocolMutateSocketRequest HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMutateSocketRequest>::Convert(::test::protocols::ChannelProtocolMutateSocketRequest&& value) {
  return ::test_protocols::ChannelProtocolMutateSocketRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
  }};
}
::test::protocols::ChannelProtocolMutateSocketResponse NaturalToHLCPPTraits<::test_protocols::ChannelProtocolMutateSocketResponse>::Convert(::test_protocols::ChannelProtocolMutateSocketResponse&& value) {
  ::test::protocols::ChannelProtocolMutateSocketResponse hlcpp;
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocols::ChannelProtocolMutateSocketResponse HLCPPToNaturalTraits<::test::protocols::ChannelProtocolMutateSocketResponse>::Convert(::test::protocols::ChannelProtocolMutateSocketResponse&& value) {
  return ::test_protocols::ChannelProtocolMutateSocketResponse{{
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocols::SyscallProtocolMethodCRequest NaturalToHLCPPTraits<::test_protocols::SyscallProtocolMethodCRequest>::Convert(::test_protocols::SyscallProtocolMethodCRequest&& value) {
  ::test::protocols::SyscallProtocolMethodCRequest hlcpp;
  hlcpp.a = ::fidl::NaturalToHLCPP(std::move(value.a()));
  hlcpp.b = ::fidl::NaturalToHLCPP(std::move(value.b()));
  return hlcpp;
}

::test_protocols::SyscallProtocolMethodCRequest HLCPPToNaturalTraits<::test::protocols::SyscallProtocolMethodCRequest>::Convert(::test::protocols::SyscallProtocolMethodCRequest&& value) {
  return ::test_protocols::SyscallProtocolMethodCRequest{{
      .a = ::fidl::HLCPPToNatural(std::move(value.a)),
      .b = ::fidl::HLCPPToNatural(std::move(value.b)),
  }};
}
::test::protocols::HandleRightsProtocolNoResponseMethodRequest NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolNoResponseMethodRequest>::Convert(::test_protocols::HandleRightsProtocolNoResponseMethodRequest&& value) {
  ::test::protocols::HandleRightsProtocolNoResponseMethodRequest hlcpp;
  hlcpp.h = ::fidl::NaturalToHLCPP(std::move(value.h()));
  return hlcpp;
}

::test_protocols::HandleRightsProtocolNoResponseMethodRequest HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolNoResponseMethodRequest>::Convert(::test::protocols::HandleRightsProtocolNoResponseMethodRequest&& value) {
  return ::test_protocols::HandleRightsProtocolNoResponseMethodRequest{{
      .h = ::fidl::HLCPPToNatural(std::move(value.h)),
  }};
}
::test::protocols::HandleRightsProtocolResponseMethodRequest NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolResponseMethodRequest>::Convert(::test_protocols::HandleRightsProtocolResponseMethodRequest&& value) {
  ::test::protocols::HandleRightsProtocolResponseMethodRequest hlcpp;
  hlcpp.h = ::fidl::NaturalToHLCPP(std::move(value.h()));
  return hlcpp;
}

::test_protocols::HandleRightsProtocolResponseMethodRequest HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolResponseMethodRequest>::Convert(::test::protocols::HandleRightsProtocolResponseMethodRequest&& value) {
  return ::test_protocols::HandleRightsProtocolResponseMethodRequest{{
      .h = ::fidl::HLCPPToNatural(std::move(value.h)),
  }};
}
::test::protocols::HandleRightsProtocolResponseMethodResponse NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolResponseMethodResponse>::Convert(::test_protocols::HandleRightsProtocolResponseMethodResponse&& value) {
  ::test::protocols::HandleRightsProtocolResponseMethodResponse hlcpp;
  hlcpp.h = ::fidl::NaturalToHLCPP(std::move(value.h()));
  return hlcpp;
}

::test_protocols::HandleRightsProtocolResponseMethodResponse HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolResponseMethodResponse>::Convert(::test::protocols::HandleRightsProtocolResponseMethodResponse&& value) {
  return ::test_protocols::HandleRightsProtocolResponseMethodResponse{{
      .h = ::fidl::HLCPPToNatural(std::move(value.h)),
  }};
}
::test::protocols::HandleRightsProtocolAnEventRequest NaturalToHLCPPTraits<::test_protocols::HandleRightsProtocolAnEventRequest>::Convert(::test_protocols::HandleRightsProtocolAnEventRequest&& value) {
  ::test::protocols::HandleRightsProtocolAnEventRequest hlcpp;
  hlcpp.h = ::fidl::NaturalToHLCPP(std::move(value.h()));
  return hlcpp;
}

::test_protocols::HandleRightsProtocolAnEventRequest HLCPPToNaturalTraits<::test::protocols::HandleRightsProtocolAnEventRequest>::Convert(::test::protocols::HandleRightsProtocolAnEventRequest&& value) {
  return ::test_protocols::HandleRightsProtocolAnEventRequest{{
      .h = ::fidl::HLCPPToNatural(std::move(value.h)),
  }};
}
::test::protocols::ProtocolEnds NaturalToHLCPPTraits<::test_protocols::ProtocolEnds>::Convert(::test_protocols::ProtocolEnds&& value) {
  ::test::protocols::ProtocolEnds hlcpp;
  hlcpp.client = ::fidl::NaturalToHLCPP(std::move(value.client()));
  hlcpp.server = ::fidl::NaturalToHLCPP(std::move(value.server()));
  hlcpp.client_opt = ::fidl::NaturalToHLCPP(std::move(value.client_opt()));
  hlcpp.server_opt = ::fidl::NaturalToHLCPP(std::move(value.server_opt()));
  return hlcpp;
}

::test_protocols::ProtocolEnds HLCPPToNaturalTraits<::test::protocols::ProtocolEnds>::Convert(::test::protocols::ProtocolEnds&& value) {
  return ::test_protocols::ProtocolEnds{{
      .client = ::fidl::HLCPPToNatural(std::move(value.client)),
      .server = ::fidl::HLCPPToNatural(std::move(value.server)),
      .client_opt = ::fidl::HLCPPToNatural(std::move(value.client_opt)),
      .server_opt = ::fidl::HLCPPToNatural(std::move(value.server_opt)),
  }};
}
::test::protocols::WithProtocolEndsClientEndsRequest NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsClientEndsRequest>::Convert(::test_protocols::WithProtocolEndsClientEndsRequest&& value) {
  ::test::protocols::WithProtocolEndsClientEndsRequest hlcpp;
  hlcpp.in = ::fidl::NaturalToHLCPP(std::move(value.in()));
  return hlcpp;
}

::test_protocols::WithProtocolEndsClientEndsRequest HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsClientEndsRequest>::Convert(::test::protocols::WithProtocolEndsClientEndsRequest&& value) {
  return ::test_protocols::WithProtocolEndsClientEndsRequest{{
      .in = ::fidl::HLCPPToNatural(std::move(value.in)),
  }};
}
::test::protocols::WithProtocolEndsClientEndsResponse NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsClientEndsResponse>::Convert(::test_protocols::WithProtocolEndsClientEndsResponse&& value) {
  ::test::protocols::WithProtocolEndsClientEndsResponse hlcpp;
  hlcpp.out = ::fidl::NaturalToHLCPP(std::move(value.out()));
  return hlcpp;
}

::test_protocols::WithProtocolEndsClientEndsResponse HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsClientEndsResponse>::Convert(::test::protocols::WithProtocolEndsClientEndsResponse&& value) {
  return ::test_protocols::WithProtocolEndsClientEndsResponse{{
      .out = ::fidl::HLCPPToNatural(std::move(value.out)),
  }};
}
::test::protocols::WithProtocolEndsServerEndsRequest NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsServerEndsRequest>::Convert(::test_protocols::WithProtocolEndsServerEndsRequest&& value) {
  ::test::protocols::WithProtocolEndsServerEndsRequest hlcpp;
  hlcpp.in = ::fidl::NaturalToHLCPP(std::move(value.in()));
  return hlcpp;
}

::test_protocols::WithProtocolEndsServerEndsRequest HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsServerEndsRequest>::Convert(::test::protocols::WithProtocolEndsServerEndsRequest&& value) {
  return ::test_protocols::WithProtocolEndsServerEndsRequest{{
      .in = ::fidl::HLCPPToNatural(std::move(value.in)),
  }};
}
::test::protocols::WithProtocolEndsServerEndsResponse NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsServerEndsResponse>::Convert(::test_protocols::WithProtocolEndsServerEndsResponse&& value) {
  ::test::protocols::WithProtocolEndsServerEndsResponse hlcpp;
  hlcpp.out = ::fidl::NaturalToHLCPP(std::move(value.out()));
  return hlcpp;
}

::test_protocols::WithProtocolEndsServerEndsResponse HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsServerEndsResponse>::Convert(::test::protocols::WithProtocolEndsServerEndsResponse&& value) {
  return ::test_protocols::WithProtocolEndsServerEndsResponse{{
      .out = ::fidl::HLCPPToNatural(std::move(value.out)),
  }};
}
::test::protocols::WithProtocolEndsStructContainingEndsRequest NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsStructContainingEndsRequest>::Convert(::test_protocols::WithProtocolEndsStructContainingEndsRequest&& value) {
  ::test::protocols::WithProtocolEndsStructContainingEndsRequest hlcpp;
  hlcpp.in = ::fidl::NaturalToHLCPP(std::move(value.in()));
  return hlcpp;
}

::test_protocols::WithProtocolEndsStructContainingEndsRequest HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsStructContainingEndsRequest>::Convert(::test::protocols::WithProtocolEndsStructContainingEndsRequest&& value) {
  return ::test_protocols::WithProtocolEndsStructContainingEndsRequest{{
      .in = ::fidl::HLCPPToNatural(std::move(value.in)),
  }};
}
::test::protocols::WithProtocolEndsStructContainingEndsResponse NaturalToHLCPPTraits<::test_protocols::WithProtocolEndsStructContainingEndsResponse>::Convert(::test_protocols::WithProtocolEndsStructContainingEndsResponse&& value) {
  ::test::protocols::WithProtocolEndsStructContainingEndsResponse hlcpp;
  hlcpp.out = ::fidl::NaturalToHLCPP(std::move(value.out()));
  return hlcpp;
}

::test_protocols::WithProtocolEndsStructContainingEndsResponse HLCPPToNaturalTraits<::test::protocols::WithProtocolEndsStructContainingEndsResponse>::Convert(::test::protocols::WithProtocolEndsStructContainingEndsResponse&& value) {
  return ::test_protocols::WithProtocolEndsStructContainingEndsResponse{{
      .out = ::fidl::HLCPPToNatural(std::move(value.out)),
  }};
}
::test::protocols::ManyParametersFifteenRequest NaturalToHLCPPTraits<::test_protocols::ManyParametersFifteenRequest>::Convert(::test_protocols::ManyParametersFifteenRequest&& value) {
  ::test::protocols::ManyParametersFifteenRequest hlcpp;
  hlcpp.p1 = ::fidl::NaturalToHLCPP(std::move(value.p1()));
  hlcpp.p2 = ::fidl::NaturalToHLCPP(std::move(value.p2()));
  hlcpp.p3 = ::fidl::NaturalToHLCPP(std::move(value.p3()));
  hlcpp.p4 = ::fidl::NaturalToHLCPP(std::move(value.p4()));
  hlcpp.p5 = ::fidl::NaturalToHLCPP(std::move(value.p5()));
  hlcpp.p6 = ::fidl::NaturalToHLCPP(std::move(value.p6()));
  hlcpp.p7 = ::fidl::NaturalToHLCPP(std::move(value.p7()));
  hlcpp.p8 = ::fidl::NaturalToHLCPP(std::move(value.p8()));
  hlcpp.p9 = ::fidl::NaturalToHLCPP(std::move(value.p9()));
  hlcpp.p10 = ::fidl::NaturalToHLCPP(std::move(value.p10()));
  hlcpp.p11 = ::fidl::NaturalToHLCPP(std::move(value.p11()));
  hlcpp.p12 = ::fidl::NaturalToHLCPP(std::move(value.p12()));
  hlcpp.p13 = ::fidl::NaturalToHLCPP(std::move(value.p13()));
  hlcpp.p14 = ::fidl::NaturalToHLCPP(std::move(value.p14()));
  hlcpp.p15 = ::fidl::NaturalToHLCPP(std::move(value.p15()));
  return hlcpp;
}

::test_protocols::ManyParametersFifteenRequest HLCPPToNaturalTraits<::test::protocols::ManyParametersFifteenRequest>::Convert(::test::protocols::ManyParametersFifteenRequest&& value) {
  return ::test_protocols::ManyParametersFifteenRequest{{
      .p1 = ::fidl::HLCPPToNatural(std::move(value.p1)),
      .p2 = ::fidl::HLCPPToNatural(std::move(value.p2)),
      .p3 = ::fidl::HLCPPToNatural(std::move(value.p3)),
      .p4 = ::fidl::HLCPPToNatural(std::move(value.p4)),
      .p5 = ::fidl::HLCPPToNatural(std::move(value.p5)),
      .p6 = ::fidl::HLCPPToNatural(std::move(value.p6)),
      .p7 = ::fidl::HLCPPToNatural(std::move(value.p7)),
      .p8 = ::fidl::HLCPPToNatural(std::move(value.p8)),
      .p9 = ::fidl::HLCPPToNatural(std::move(value.p9)),
      .p10 = ::fidl::HLCPPToNatural(std::move(value.p10)),
      .p11 = ::fidl::HLCPPToNatural(std::move(value.p11)),
      .p12 = ::fidl::HLCPPToNatural(std::move(value.p12)),
      .p13 = ::fidl::HLCPPToNatural(std::move(value.p13)),
      .p14 = ::fidl::HLCPPToNatural(std::move(value.p14)),
      .p15 = ::fidl::HLCPPToNatural(std::move(value.p15)),
  }};
}
::test::protocols::MethodWithUnionUnionMethodRequest NaturalToHLCPPTraits<::test_protocols::MethodWithUnionUnionMethodRequest>::Convert(::test_protocols::MethodWithUnionUnionMethodRequest&& value) {
  ::test::protocols::MethodWithUnionUnionMethodRequest hlcpp;
  hlcpp.u = ::fidl::NaturalToHLCPP(std::move(value.u()));
  return hlcpp;
}

::test_protocols::MethodWithUnionUnionMethodRequest HLCPPToNaturalTraits<::test::protocols::MethodWithUnionUnionMethodRequest>::Convert(::test::protocols::MethodWithUnionUnionMethodRequest&& value) {
  return ::test_protocols::MethodWithUnionUnionMethodRequest{{
      .u = ::fidl::HLCPPToNatural(std::move(value.u)),
  }};
}
::test::protocols::MethodWithUnionUnionMethodResponse NaturalToHLCPPTraits<::test_protocols::MethodWithUnionUnionMethodResponse>::Convert(::test_protocols::MethodWithUnionUnionMethodResponse&& value) {
  ::test::protocols::MethodWithUnionUnionMethodResponse hlcpp;
  hlcpp.u = ::fidl::NaturalToHLCPP(std::move(value.u()));
  return hlcpp;
}

::test_protocols::MethodWithUnionUnionMethodResponse HLCPPToNaturalTraits<::test::protocols::MethodWithUnionUnionMethodResponse>::Convert(::test::protocols::MethodWithUnionUnionMethodResponse&& value) {
  return ::test_protocols::MethodWithUnionUnionMethodResponse{{
      .u = ::fidl::HLCPPToNatural(std::move(value.u)),
  }};
}

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

::test_protocols::WithErrorSyntaxResponseAsStructResult HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ResponseAsStruct_Result>::Convert(::test::protocols::WithErrorSyntax_ResponseAsStruct_Result&& value) {
  using _NaturalUnion = ::test_protocols::WithErrorSyntaxResponseAsStructResult;
  switch (value.Which()) {
    case ::test::protocols::WithErrorSyntax_ResponseAsStruct_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocols::WithErrorSyntax_ResponseAsStruct_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::protocols::WithErrorSyntax_ResponseAsStruct_Result");
  }
}
::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult>::Convert(::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult&& value) {
  ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result>::Convert(::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result&& value) {
  using _NaturalUnion = ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult;
  switch (value.Which()) {
    case ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocols::WithErrorSyntax_ErrorAsPrimitive_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::protocols::WithErrorSyntax_ErrorAsPrimitive_Result");
  }
}
::test::protocols::WithErrorSyntax_ErrorAsEnum_Result NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxErrorAsEnumResult>::Convert(::test_protocols::WithErrorSyntaxErrorAsEnumResult&& value) {
  ::test::protocols::WithErrorSyntax_ErrorAsEnum_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocols::WithErrorSyntaxErrorAsEnumResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocols::WithErrorSyntaxErrorAsEnumResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocols::WithErrorSyntaxErrorAsEnumResult HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_ErrorAsEnum_Result>::Convert(::test::protocols::WithErrorSyntax_ErrorAsEnum_Result&& value) {
  using _NaturalUnion = ::test_protocols::WithErrorSyntaxErrorAsEnumResult;
  switch (value.Which()) {
    case ::test::protocols::WithErrorSyntax_ErrorAsEnum_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocols::WithErrorSyntax_ErrorAsEnum_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::protocols::WithErrorSyntax_ErrorAsEnum_Result");
  }
}
::test::protocols::WithErrorSyntax_HandleInResult_Result NaturalToHLCPPTraits<::test_protocols::WithErrorSyntaxHandleInResultResult>::Convert(::test_protocols::WithErrorSyntaxHandleInResultResult&& value) {
  ::test::protocols::WithErrorSyntax_HandleInResult_Result hlcpp;
  switch (value.Which()) {
    case ::test_protocols::WithErrorSyntaxHandleInResultResult::Tag::kResponse:
      hlcpp.set_response(::fidl::NaturalToHLCPP(std::move(value.response().value())));
      break;
    case ::test_protocols::WithErrorSyntaxHandleInResultResult::Tag::kErr:
      hlcpp.set_err(::fidl::NaturalToHLCPP(std::move(value.err().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocols::WithErrorSyntaxHandleInResultResult HLCPPToNaturalTraits<::test::protocols::WithErrorSyntax_HandleInResult_Result>::Convert(::test::protocols::WithErrorSyntax_HandleInResult_Result&& value) {
  using _NaturalUnion = ::test_protocols::WithErrorSyntaxHandleInResultResult;
  switch (value.Which()) {
    case ::test::protocols::WithErrorSyntax_HandleInResult_Result::Tag::kResponse:
      return _NaturalUnion::WithResponse(
          ::fidl::HLCPPToNatural(std::move(value.response())));
    case ::test::protocols::WithErrorSyntax_HandleInResult_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::protocols::WithErrorSyntax_HandleInResult_Result");
  }
}
::test::protocols::TheUnion NaturalToHLCPPTraits<::test_protocols::TheUnion>::Convert(::test_protocols::TheUnion&& value) {
  ::test::protocols::TheUnion hlcpp;
  switch (value.Which()) {
    case ::test_protocols::TheUnion::Tag::kV:
      hlcpp.set_v(::fidl::NaturalToHLCPP(std::move(value.v().value())));
      break;
    default:
      break;
  }
  return hlcpp;
}

::test_protocols::TheUnion HLCPPToNaturalTraits<::test::protocols::TheUnion>::Convert(::test::protocols::TheUnion&& value) {
  using _NaturalUnion = ::test_protocols::TheUnion;
  switch (value.Which()) {
    case ::test::protocols::TheUnion::Tag::kV:
      return _NaturalUnion::WithV(
          ::fidl::HLCPPToNatural(std::move(value.v())));
    default:
      return _NaturalUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{});
  }
}

#pragma clang diagnostic pop

}  // namespace internal
}  // namespace fidl