tools/fidl/fidlgen_hlcpp/goldens/error_syntax.h.golden

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

// fidl_experiment = output_index_json

#pragma once

#include <test/errorsyntax/parent/cpp/fidl.h>

#include "lib/fidl/cpp/internal/header.h"
namespace test {
namespace errorsyntax {

//
// Domain objects declarations
//

class ExampleUseOfErrorSyntaxCallWhichMayFailRequest;

class ExampleUseOfErrorSyntax_CallWhichMayFail_Response;

class ExampleUseOfErrorSyntax_CallWhichMayFail_Result;

#ifdef __Fuchsia__

class ExampleUseOfErrorSyntax;
using ExampleUseOfErrorSyntaxHandle = ::fidl::InterfaceHandle<ExampleUseOfErrorSyntax>;

#endif  // __Fuchsia__

class ExampleUseOfErrorSyntaxCallWhichMayFailRequest final {
 public:
  static const fidl_type_t* FidlType;

  ::std::string s;

  static inline ::std::unique_ptr<ExampleUseOfErrorSyntaxCallWhichMayFailRequest> New() { return ::std::make_unique<ExampleUseOfErrorSyntaxCallWhichMayFailRequest>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExampleUseOfErrorSyntaxCallWhichMayFailRequest* value, size_t _offset);
  zx_status_t Clone(ExampleUseOfErrorSyntaxCallWhichMayFailRequest* result) const;
};

inline zx_status_t Clone(const ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest& _value,
                         ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest* _result) {
  return _value.Clone(_result);
}

using ExampleUseOfErrorSyntaxCallWhichMayFailRequestPtr = ::std::unique_ptr<ExampleUseOfErrorSyntaxCallWhichMayFailRequest>;

class ExampleUseOfErrorSyntax_CallWhichMayFail_Response final {
 public:
  static const fidl_type_t* FidlType;
  ExampleUseOfErrorSyntax_CallWhichMayFail_Response() = default;
  explicit ExampleUseOfErrorSyntax_CallWhichMayFail_Response(int64_t v) : value(std::move(v)) {}
  int64_t ResultValue_() { return std::move(value); }
  explicit ExampleUseOfErrorSyntax_CallWhichMayFail_Response(::std::tuple<int64_t> _value_tuple) {
    std::tie(value) = std::move(_value_tuple);
  }
  operator ::std::tuple<int64_t>() && {
    return std::make_tuple(std::move(value));
  }

  int64_t value{};

  static inline ::std::unique_ptr<ExampleUseOfErrorSyntax_CallWhichMayFail_Response> New() { return ::std::make_unique<ExampleUseOfErrorSyntax_CallWhichMayFail_Response>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExampleUseOfErrorSyntax_CallWhichMayFail_Response* value, size_t _offset);
  zx_status_t Clone(ExampleUseOfErrorSyntax_CallWhichMayFail_Response* result) const;
};

inline zx_status_t Clone(const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response& _value,
                         ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response* _result) {
  return _value.Clone(_result);
}

using ExampleUseOfErrorSyntax_CallWhichMayFail_ResponsePtr = ::std::unique_ptr<ExampleUseOfErrorSyntax_CallWhichMayFail_Response>;

class ExampleUseOfErrorSyntax_CallWhichMayFail_Result final {
 public:
  static const fidl_type_t* FidlType;

  ExampleUseOfErrorSyntax_CallWhichMayFail_Result();
  ~ExampleUseOfErrorSyntax_CallWhichMayFail_Result();

  ExampleUseOfErrorSyntax_CallWhichMayFail_Result(ExampleUseOfErrorSyntax_CallWhichMayFail_Result&&);
  ExampleUseOfErrorSyntax_CallWhichMayFail_Result& operator=(ExampleUseOfErrorSyntax_CallWhichMayFail_Result&&);

  static ExampleUseOfErrorSyntax_CallWhichMayFail_Result WithResponse(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response&&);
  static ExampleUseOfErrorSyntax_CallWhichMayFail_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kResponse = 1,  // 0x1
    kErr = 2,       // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExampleUseOfErrorSyntax_CallWhichMayFail_Result> New() { return ::std::make_unique<ExampleUseOfErrorSyntax_CallWhichMayFail_Result>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExampleUseOfErrorSyntax_CallWhichMayFail_Result* value, size_t offset);
  zx_status_t Clone(ExampleUseOfErrorSyntax_CallWhichMayFail_Result* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_response() const { return tag_ == ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::kResponse; }

  ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response& response() {
    EnsureStorageInitialized(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::kResponse);
    return response_;
  }

  const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  ExampleUseOfErrorSyntax_CallWhichMayFail_Result& set_response(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response value);

  bool is_err() const { return tag_ == ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::kErr; }

  uint32_t& err() {
    EnsureStorageInitialized(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::kErr);
    return err_;
  }

  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  ExampleUseOfErrorSyntax_CallWhichMayFail_Result& set_err(uint32_t value);

  ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag Which() const {
    return ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>;
  ExampleUseOfErrorSyntax_CallWhichMayFail_Result(fpromise::ok_result<int64_t>&& result) {
    set_response(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response{std::move(result.value)});
  }
  ExampleUseOfErrorSyntax_CallWhichMayFail_Result(fpromise::error_result<uint32_t>&& result) {
    set_err(std::move(result.error));
  }
  ExampleUseOfErrorSyntax_CallWhichMayFail_Result(fpromise::result<int64_t, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<int64_t, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<int64_t> value_tuple = std::move(response());
    return fpromise::ok(std::move(std::get<0>(value_tuple)));
  }

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::Invalid);
  union {
    ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response response_;
    uint32_t err_;
  };
};

inline zx_status_t Clone(const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result& value,
                         ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result* result) {
  return value.Clone(result);
}

using ExampleUseOfErrorSyntax_CallWhichMayFail_ResultPtr = ::std::unique_ptr<ExampleUseOfErrorSyntax_CallWhichMayFail_Result>;

#ifdef __Fuchsia__

namespace _internal {
__LOCAL extern "C" const fidl_type_t test_errorsyntax_parent_ParentUsesErrorSyntaxComposedCallWhichMayFailRequestTable;

__LOCAL extern "C" const fidl_type_t test_errorsyntax_ExampleUseOfErrorSyntaxCallWhichMayFailRequestTable;

}  // namespace _internal

class ExampleUseOfErrorSyntax_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage ComposedCallWhichMayFail(::fidl::MessageEncoder* _encoder, ::std::string* s) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, s, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage CallWhichMayFail(::fidl::MessageEncoder* _encoder, ::std::string* s) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, s, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};
namespace _internal {
__LOCAL extern "C" const fidl_type_t test_errorsyntax_parent_ParentUsesErrorSyntax_ComposedCallWhichMayFail_ResultTable;

__LOCAL extern "C" const fidl_type_t test_errorsyntax_ExampleUseOfErrorSyntax_CallWhichMayFail_ResultTable;

}  // namespace _internal

class ExampleUseOfErrorSyntax_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage ComposedCallWhichMayFail(::fidl::MessageEncoder* _encoder, ::test::errorsyntax::parent::ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result* ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage CallWhichMayFail(::fidl::MessageEncoder* _encoder, ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result* ExampleUseOfErrorSyntax_CallWhichMayFail_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ExampleUseOfErrorSyntax_CallWhichMayFail_Result, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__

}  // namespace errorsyntax
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest>
    : public EncodableCodingTraits<::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest, 16> {};

template <>
struct HasPadding<::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest> : public internal::BoolConstant<
                                                                                                     !HasPadding<::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest>::value && IsMemcpyCompatible<::std::string>::value> {};

inline zx_status_t Clone(const ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest& value,
                         ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest* result) {
  return ::test::errorsyntax::Clone(value, result);
}

template <>
struct Equality<::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest> {
  bool operator()(const ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest& _lhs, const ::test::errorsyntax::ExampleUseOfErrorSyntaxCallWhichMayFailRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.s, _rhs.s)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response>
    : public EncodableCodingTraits<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response, 8> {};

template <>
struct IsMemcpyCompatible<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response> : public internal::BoolConstant<
                                                                                                        !HasPadding<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response>::value && IsMemcpyCompatible<int64_t>::value> {};

inline zx_status_t Clone(const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response& value,
                         ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response* result) {
  return ::test::errorsyntax::Clone(value, result);
}

template <>
struct Equality<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response> {
  bool operator()(const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response& _lhs, const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Response& _rhs) const {
    if (!::fidl::Equals(_lhs.value, _rhs.value)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>
    : public EncodableCodingTraits<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>> {
  static constexpr size_t inline_size_v2 = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result);

    ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result& value,
                         ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result* result) {
  return ::test::errorsyntax::Clone(value, result);
}

template <>
struct Equality<::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result> {
  bool operator()(const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result& _lhs, const ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::Invalid):
        return true;
      case ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);

      default:
        return false;
    }
  }
};

//
// Proxies and stubs declarations
//
}  // namespace fidl
namespace test {
namespace errorsyntax {

#ifdef __Fuchsia__

using ExampleUseOfErrorSyntaxPtr = ::fidl::InterfacePtr<ExampleUseOfErrorSyntax>;
class ExampleUseOfErrorSyntax_Proxy;
class ExampleUseOfErrorSyntax_Stub;
class ExampleUseOfErrorSyntax_EventSender;
class ExampleUseOfErrorSyntax_Sync;
using ExampleUseOfErrorSyntaxSyncPtr = ::fidl::SynchronousInterfacePtr<ExampleUseOfErrorSyntax>;
class ExampleUseOfErrorSyntax_SyncProxy;

namespace internal {

constexpr uint64_t kExampleUseOfErrorSyntax_ComposedCallWhichMayFail_Ordinal = 0x3179cf8f46814221lu;

constexpr ::fidl::MessageDynamicFlags kExampleUseOfErrorSyntax_ComposedCallWhichMayFail_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kExampleUseOfErrorSyntax_CallWhichMayFail_Ordinal = 0x3424ff83ce3004a2lu;

constexpr ::fidl::MessageDynamicFlags kExampleUseOfErrorSyntax_CallWhichMayFail_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
}  // namespace internal

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class ExampleUseOfErrorSyntax {
 public:
  using Proxy_ = ::test::errorsyntax::ExampleUseOfErrorSyntax_Proxy;
  using Stub_ = ::test::errorsyntax::ExampleUseOfErrorSyntax_Stub;
  using EventSender_ = ::test::errorsyntax::ExampleUseOfErrorSyntax_EventSender;
  using Sync_ = ::test::errorsyntax::ExampleUseOfErrorSyntax_Sync;
  virtual ~ExampleUseOfErrorSyntax();
  using ComposedCallWhichMayFailCallback =
      fit::function<void(::test::errorsyntax::parent::ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result)>;

  virtual void ComposedCallWhichMayFail(::std::string s, ComposedCallWhichMayFailCallback callback) = 0;
  using CallWhichMayFailCallback =
      fit::function<void(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result)>;

  virtual void CallWhichMayFail(::std::string s, CallWhichMayFailCallback callback) = 0;
};

class ExampleUseOfErrorSyntax_RequestDecoder {
 public:
  ExampleUseOfErrorSyntax_RequestDecoder() = default;
  virtual ~ExampleUseOfErrorSyntax_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void ComposedCallWhichMayFail(::std::string s) = 0;
  virtual void CallWhichMayFail(::std::string s) = 0;
};

class ExampleUseOfErrorSyntax_ResponseDecoder {
 public:
  ExampleUseOfErrorSyntax_ResponseDecoder() = default;
  virtual ~ExampleUseOfErrorSyntax_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void ComposedCallWhichMayFail(::test::errorsyntax::parent::ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result) = 0;
  virtual void CallWhichMayFail(::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result ExampleUseOfErrorSyntax_CallWhichMayFail_Result) = 0;
};

class ExampleUseOfErrorSyntax_EventSender {
 public:
  virtual ~ExampleUseOfErrorSyntax_EventSender();
};

class ExampleUseOfErrorSyntax_Sync {
 public:
  using Proxy_ = ::test::errorsyntax::ExampleUseOfErrorSyntax_SyncProxy;
  virtual ~ExampleUseOfErrorSyntax_Sync();
  virtual zx_status_t ComposedCallWhichMayFail(::std::string s, ::test::errorsyntax::parent::ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result* out_ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result) = 0;
  virtual zx_status_t CallWhichMayFail(::std::string s, ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result* out_ExampleUseOfErrorSyntax_CallWhichMayFail_Result) = 0;
};

class ExampleUseOfErrorSyntax_Proxy final : public ::fidl::internal::Proxy, public ExampleUseOfErrorSyntax {
 public:
  explicit ExampleUseOfErrorSyntax_Proxy(::fidl::internal::ProxyController* controller);
  ~ExampleUseOfErrorSyntax_Proxy() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.errorsyntax/ExampleUseOfErrorSyntax.ComposedCallWhichMayFail
  void ComposedCallWhichMayFail(::std::string s, ComposedCallWhichMayFailCallback callback) override;
  // cts-coverage-fidl-name:test.errorsyntax/ExampleUseOfErrorSyntax.CallWhichMayFail
  void CallWhichMayFail(::std::string s, CallWhichMayFailCallback callback) override;

 private:
  ExampleUseOfErrorSyntax_Proxy(const ::test::errorsyntax::ExampleUseOfErrorSyntax_Proxy&) = delete;
  ExampleUseOfErrorSyntax_Proxy& operator=(const ::test::errorsyntax::ExampleUseOfErrorSyntax_Proxy&) = delete;

  ::fidl::internal::ProxyController* controller_;
};

class ExampleUseOfErrorSyntax_Stub final : public ::fidl::internal::Stub, public ::test::errorsyntax::ExampleUseOfErrorSyntax_EventSender {
 public:
  typedef class ::test::errorsyntax::ExampleUseOfErrorSyntax ExampleUseOfErrorSyntax_clazz;
  explicit ExampleUseOfErrorSyntax_Stub(::test::errorsyntax::ExampleUseOfErrorSyntax_Stub::ExampleUseOfErrorSyntax_clazz* impl);
  ~ExampleUseOfErrorSyntax_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;

 private:
  ::test::errorsyntax::ExampleUseOfErrorSyntax_Stub::ExampleUseOfErrorSyntax_clazz* impl_;
};

class ExampleUseOfErrorSyntax_SyncProxy : public ::test::errorsyntax::ExampleUseOfErrorSyntax_Sync {
 public:
  explicit ExampleUseOfErrorSyntax_SyncProxy(::zx::channel channel);
  ~ExampleUseOfErrorSyntax_SyncProxy() override;
  // cts-coverage-fidl-name:test.errorsyntax/ExampleUseOfErrorSyntax.ComposedCallWhichMayFail
  zx_status_t ComposedCallWhichMayFail(::std::string s, ::test::errorsyntax::parent::ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result* out_ParentUsesErrorSyntax_ComposedCallWhichMayFail_Result) override;
  // cts-coverage-fidl-name:test.errorsyntax/ExampleUseOfErrorSyntax.CallWhichMayFail
  zx_status_t CallWhichMayFail(::std::string s, ::test::errorsyntax::ExampleUseOfErrorSyntax_CallWhichMayFail_Result* out_ExampleUseOfErrorSyntax_CallWhichMayFail_Result) override;

 private:
  ::fidl::internal::SynchronousProxy proxy_;
  friend class ::fidl::SynchronousInterfacePtr<ExampleUseOfErrorSyntax>;
};

#endif  // __Fuchsia__

}  // namespace errorsyntax
}  // namespace test