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

#pragma once

#include <test/middle/cpp/fidl.h>

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

//
// Domain objects declarations
//

class Baz;

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

  ::test::middle::Bar g{};

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

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

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

using BazPtr = ::std::unique_ptr<Baz>;

}  // namespace transitivedependencies
}  // namespace test
namespace fidl {
template <>
struct CodingTraits<::test::transitivedependencies::Baz>
    : public EncodableCodingTraits<::test::transitivedependencies::Baz, 4> {};

template <>
struct IsMemcpyCompatible<::test::transitivedependencies::Baz> : public internal::BoolConstant<
                                                                     !HasPadding<::test::transitivedependencies::Baz>::value && IsMemcpyCompatible<::test::middle::Bar>::value> {};

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

template <>
struct Equality<::test::transitivedependencies::Baz> {
  bool operator()(const ::test::transitivedependencies::Baz& _lhs, const ::test::transitivedependencies::Baz& _rhs) const {
    if (!::fidl::Equals(_lhs.g, _rhs.g)) {
      return false;
    }
    return true;
  }
};

//
// Proxies and stubs declarations
//
}  // namespace fidl
